AHUACM寒假集训VI（网络流）

已于 2022-02-06 14:40:23 修改
阅读量955 收藏
点赞数 1
文章标签： 网络
于 2022-01-28 17:19:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lznw_/article/details/122734005
版权
luoguP2472.蜥蜴

传送门
题目大意： R × C ( 1 ≤ R , C ≤ 20 ) R\times C(1\leq R,C\leq20) R×C(1≤R,C≤20)的网格上，每个格子有一个高度 h i j ( 1 ≤ h ≤ 3 ) h_{ij}(1\leq h\leq3) hij​(1≤h≤3)，每次有蜥蜴跳离这个格子，其高度就 − 1 -1 −1，不能跳入任何高度为 0 0 0的格子，蜥蜴在任何时刻也不能够站立在高度为 0 0 0的格子上面，一开始一些高度不为 0 0 0的格子上面有一些蜥蜴，蜥蜴一次最多跳跃距离为 d ( 1 ≤ d ≤ 4 ) d(1\leq d\leq4) d(1≤d≤4)（欧几里得距离），蜥蜴在跳出网格前每一步都必须待在一个可以站立的柱子上，问最少有多少蜥蜴跳不出网格。

思路：
考虑网络流，源点 S S S向每个初始有蜥蜴的格点连一条容量为1的边，每个能够跳出网格的格子向汇点 T T T连一条容量为 i n f inf inf的边，每个网格向它一步能跳到的网格连一条容量为 i n f inf inf的边，每个网格的高度 h i j h_{ij} hij​可以视作该点的容量，将其拆为出，入两个点即可，对这张图跑一边最大流，答案就是初始的蜥蜴总数 − m a x f l o w -maxflow −maxflow。

代码：

#include<bits/stdc++.h>
#include<unordered_map>
#include<unordered_set>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
//#define int LL
#define endl '\n'
#define inf 0x3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#pragma warning(disable :4996)
const double eps = 1e-8;
const LL mod = 1000000007;
const LL MOD = 998244353;
const int maxn = 3000010;
const int maxv = 1010;

int R, C, D;
int high[30][30];
char field[30][30];

struct edge {
	int to, cap, rev;
};
vector<edge> G[maxv];
int level[maxv], iter[maxv];

void add_edge(int from, int to, int cap)
{
	G[from].push_back(edge{ to,cap,(int)G[to].size() });
	G[to].push_back(edge{ from,0,(int)G[from].size() - 1 });
}

void bfs(int s)
{
	memset(level, -1, sizeof(level));
	queue<int> que;
	level[s] = 0;
	que.push(s);
	while (!que.empty())
	{
		int v = que.front();
		que.pop();
		for (int i = 0; i < G[v].size(); i++)
		{
			edge& e = G[v][i];
			if (e.cap > 0 && level[e.to] < 0)
			{
				level[e.to] = level[v] + 1;
				que.push(e.to);
			}
		}
	}
}

int dfs(int v, int t, int f)
{
	if (v == t)
		return f;
	for (int& i = iter[v]; i < G[v].size(); i++)
	{
		edge& e = G[v][i];
		if (e.cap > 0 && level[v] < level[e.to])
		{
			int d = dfs(e.to, t, min(f, e.cap));
			if (d > 0)
			{
				e.cap -= d;
				G[e.to][e.rev].cap += d;
				return d;

			}
		}
	}

	return 0;
}

int max_flow(int s, int t)
{
	int flow = 0;
	while (true)
	{
		bfs(s);
		if (level[t] < 0)
			return flow;
		memset(iter, 0, sizeof(iter));
		int f;
		while ((f = dfs(s, t, INF)) > 0)
			flow += f;
	}

	return flow;
}

int dis(int x1, int y1, int x2, int y2)
{
	return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
}

void solve()
{
	//（i-1）*C+j：i行j列入
	//（j-1）*C+j+R*C：i行j出
	int ans = 0;
	int S = R * C * 2 + 1, T = R * C * 2 + 2;
	for (int i = 1; i <= R; i++)
	{
		for (int j = 1; j <= C; j++)
		{
			if (high[i][j] > 0)
			{
				int v = (i - 1) * C + j;
				add_edge(v, v + R * C, high[i][j]);
				for (int k = 1; k <= R; k++)
				{
					for (int l = 1; l <= C; l++)
					{
						int u = (k - 1) * C + l;
						if (dis(i, j, k, l) <= D * D && !(k == i && l == j) && high[k][l] > 0)
							add_edge(v + R * C, u, inf);
					}
				}
				if (field[i][j] == 'L')
				{
					add_edge(S, v, 1);
					ans++;
				}
				if (i <= D || i + D > R || j <= D || j + D > C)
					add_edge(v + R * C, T, inf);
			}
		}
	}
	cout << ans - max_flow(S, T) << endl;
}

int main()
{
	IOS;
	char tmp;
	cin >> R >> C >> D;
	for (int i = 1; i <= R; i++)
	{
		for (int j = 1; j <= C; j++)
		{
			cin >> tmp;
			high[i][j] = tmp - '0';
		}
	}
	for(int i = 1; i <= R; i++)
	{
		for (int j = 1; j <= C; j++)
			cin >> field[i][j];
	}
	solve();

	return 0;
}
luoguP2053.修车

传送门
题目大意：
N ( N ≤ 60 ) N(N\leq60) N(N≤60)辆车， M ( M ≤ 9 ) M(M\leq9) M(M≤9)个修理工，第 i i i辆车在第 j j j个修理工处需要的修复时间为 T i j T_{ij} Tij​，使所有车辆全部修复完毕所花费的平均时间最少（包括等待时间以及修理时间）。

思路：
平均时间最少也就是要最小化总时间，考虑在某个修理工处的一个修车安排的总时间是如何产生的。设一个修理工处的总时间为 A A A，修理的车辆先后为 N 1 , N 2 , N 3 N_{1},N_{2},N_{3} N1​,N2​,N3​，于是就有 A = N 1 + ( N 1 + N 2 ) + ( N 1 + N 2 + N 3 ) A=N_{1}+(N_{1}+N_{2})+(N_{1}+N_{2}+N_{3}) A=N1​+(N1​+N2​)+(N1​+N2​+N3​)，即 A = N 3 + 2 N 2 + 3 N 1 A=N_{3}+2N_{2}+3N_{1} A=N3​+2N2​+3N1​，于是可以看出一个修理工处如果修 k k k辆车，那么相当于所修里的车分别花费 1 ∼ k 1\sim k 1∼k倍的时间，于是我们对于每个修理工，可以将其拆为 N N N个点，表示花费 1 ∼ N 1\sim N 1∼N倍的时间，将这 N M NM NM个点向汇点 T T T连容量为 1 1 1，费用 0 0 0的边。之后对于每辆车，向每个修理工及其各倍数的点连一条容量为 1 1 1，费用为 T i j × T_{ij}\times Tij​×倍数的边，再从源点 S S S向每辆车连容量为 1 1 1，费用为 0 0 0的边，之后在这张图上跑流量为 N N N的最小费用流即可求出最少的总时间。

代码：

#include<bits/stdc++.h>
#include<unordered_map>
#include<unordered_set>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
//#define int LL
#define endl '\n'
#define inf 0x3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#pragma warning(disable :4996)
const double eps = 1e-8;
const LL mod = 1000000007;
const LL MOD = 998244353;
const int maxv = 4010;

struct edge {
	int to, cap, cost, rev;
};

int V;//顶点数
vector<edge> G[maxv];
int h[maxv], dist[maxv], prevv[maxv], preve[maxv];

void add_edge(int from, int to, int cap, int cost)
{
	G[from].push_back(edge{ to, cap, cost, (int)G[to].size() });
	G[to].push_back(edge{ from, 0, -cost, (int)G[from].size() - 1 });
}

int min_cost_flow(int s, int t, int f)//求s->t,f流之最小费用流，若不能再增广，返回-1，即无解
{
	int res = 0;
	memset(h, 0, sizeof(h));
	while (f > 0)
	{
		priority_queue<PII, vector<PII>, greater<PII>> que;
		memset(dist, inf, sizeof(dist));
		dist[s] = 0;
		que.push(PII(0, s));
		while (!que.empty())
		{
			PII p = que.top();
			que.pop();
			int v = p.second;
			if (dist[v] < p.first)
				continue;
			for (int i = 0; i < G[v].size(); i++)
			{
				edge& e = G[v][i];
				if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to])
				{
					dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
					prevv[e.to] = v;
					preve[e.to] = i;
					que.push(PII(dist[e.to], e.to));
				}
			}
		}
		if (dist[t] == inf)
			return -1;
		for (int v = 1; v <= V; v++)
			h[v] += dist[v];
		int d = f;
		for (int v = t; v != s; v = prevv[v])
			d = min(d, G[prevv[v]][preve[v]].cap);
		f -= d;
		res += d * h[t];
		for (int v = t; v != s; v = prevv[v])
		{
			edge& e = G[prevv[v]][preve[v]];
			e.cap -= d;
			G[v][e.rev].cap += d;
		}
	}

	return res;
}

int N, M, C[70][20];

void solve()
{
	//1~N:顾客
	//k*N+1~(k+1)*N:k号修理工
	int S = N * (M + 1) + 1, T = S + 1;
	V = T;
	for (int i = 1; i <= N; i++)
		add_edge(S, i, 1, 0);
	for (int i = 1; i <= M; i++)
	{
		for (int j = 1; j <= N; j++)
		{
			add_edge(i * N + j, T, 1, 0);
			for (int k = 1; k <= N; k++)
				add_edge(k, i * N + j, 1, C[k][i] * j);
		}
	}
	cout << setiosflags(ios::fixed) << setprecision(2) << (double)min_cost_flow(S, T, N) / N << endl;
}

int main()
{
	IOS;
	cin >> M >> N;
	for (int i = 1; i <= N; i++)
	{
		for (int j = 1; j <= M; j++)
			cin >> C[i][j];
	}
	solve();

	return 0;
}
luoguP3227.切糕

传送门
题目大意：
一个 P × Q × R ( 1 ≤ P , Q , R ≤ 40 ) P\times Q\times R(1\leq P,Q,R\leq40) P×Q×R(1≤P,Q,R≤40)的长方体点阵，每个点 ( x , y , z ) (x,y,z) (x,y,z)上面有一个权值 v ( x , y , z ) v(x,y,z) v(x,y,z)，在每个 ( x . y ) (x.y) (x.y)处，选择且仅选择一个 z z z值，获取权值 v ( x , y , z ) v(x,y,z) v(x,y,z)，但是在与 ( x , y ) (x,y) (x,y)相邻的坐标（ 4 4 4个方向）处所选择的 z z z值与在 ( x , y ) (x,y) (x,y)处所选择的相差不能超过 D D D，求可以获得的最小总权值。

思路：
考虑没有限制 D D D的时候，显然直接在每个 ( x , y ) (x,y) (x,y)处直接取 v ( x , y , z ) v(x,y,z) v(x,y,z)最小的 z z z即可，这样的选择亦可以转化为一个最小割模型，即对点阵中所有的点建点，从源点 S S S向每个 ( x , y , 1 ) (x,y,1) (x,y,1)对应的点连一条容量为 i n f inf inf的边，之后对所有 ( x , y , R ) (x,y,R) (x,y,R)对应的点向汇点 T T T连一条容量为 v ( x , y , R ) v(x,y,R) v(x,y,R)的边，再对剩下的所有 ( x , y , z ) (x,y,z) (x,y,z)对应的点向 ( x , y , z + 1 ) (x,y,z+1) (x,y,z+1)对应的点连一条容量为 v ( x , y , z ) v(x,y,z) v(x,y,z)的边即可。因为这样建图相当于每一个 ( x , y ) (x,y) (x,y)上都必须割去一个边，于是该图的最小割就是没有限制的情况下的答案了。

再考虑有约束 D D D的情况，我们只需要再刚才的图上再加入几条新的边，即当 z > D z>D z>D时，对所有的 ( x , y , z ) (x,y,z) (x,y,z)对应的点向其所有相邻坐标对应的 z − D z-D z−D高度的点连一条容量为 i n f inf inf的边即可，加完这些边的新图的最小割就是带有限制的情况下的答案了。
设 D = 1 D=1 D=1，下图的红色边是一条新加的边，这条边可以保证蓝色和紫色的两条边不会同时在最小割中被割去，因为如果同时割去，那么至少还要再割去一条 S → 1 → 2 → 3 S\to 1\to 2\to 3 S→1→2→3或者 5 → 6 → S 5\to 6\to S 5→6→S上的一条边，那么显然直接放弃紫色或者蓝色的边显然割会更小。
在这里插入图片描述
代码：

#include<bits/stdc++.h>
#include<unordered_map>
#include<unordered_set>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
//#define int LL
#define endl '\n'
#define inf 0x3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#pragma warning(disable :4996)
const double eps = 1e-8;
const LL mod = 1000000007;
const LL MOD = 998244353;
const int maxv = 70010;

struct edge {
	int to, cap, rev;
};
vector<edge> G[maxv];
int level[maxv], iter[maxv];
int P, Q, R, D;
int V[50][50][50];
int di[4] = { 0,0,1,-1 };
int dj[4] = { 1,-1,0,0 };

void add_edge(int from, int to, int cap)
{
	G[from].push_back(edge{ to,cap,(int)G[to].size() });
	G[to].push_back(edge{ from,0,(int)G[from].size() - 1 });
}

void bfs(int s)
{
	memset(level, -1, sizeof(level));
	queue<int> que;
	level[s] = 0;
	que.push(s);
	while (!que.empty())
	{
		int v = que.front();
		que.pop();
		for (int i = 0; i < G[v].size(); i++)
		{
			edge& e = G[v][i];
			if (e.cap > 0 && level[e.to] < 0)
			{
				level[e.to] = level[v] + 1;
				que.push(e.to);
			}
		}
	}
}

int dfs(int v, int t, int f)
{
	if (v == t)
		return f;
	for (int& i = iter[v]; i < G[v].size(); i++)
	{
		edge& e = G[v][i];
		if (e.cap > 0 && level[v] < level[e.to])
		{
			int d = dfs(e.to, t, min(f, e.cap));
			if (d > 0)
			{
				e.cap -= d;
				G[e.to][e.rev].cap += d;
				return d;

			}
		}
	}

	return 0;
}

int max_flow(int s, int t)
{
	int flow = 0;
	while (true)
	{
		bfs(s);
		if (level[t] < 0)
			return flow;
		memset(iter, 0, sizeof(iter));
		int f;
		while ((f = dfs(s, t, inf)) > 0)
			flow += f;
	}

	return flow;
}

inline int getnum(int i, int j, int k)
{
	return P * Q * (k - 1) + Q * (i - 1) + j;
}

void solve()
{
	int S = P * Q * R + 1, T = S + 1;
	for (int i = 1; i <= P; i++)
	{
		for (int j = 1; j <= Q; j++)
		{
			for (int k = 1; k <= R; k++)
			{
				int v = getnum(i, j, k), u = getnum(i, j, k + 1);
				if (k == 1)
					add_edge(S, v, inf);
				if (k == R)
					add_edge(v, T, V[i][j][k]);
				else
					add_edge(v, u, V[i][j][k]);
				if (k > D)
				{
					for (int l = 0; l < 4; l++)
					{
						int ni = i + di[l], nj = j + dj[l];
						if (ni >= 1 && ni <= P && nj >= 1 && nj <= Q)
							add_edge(v, getnum(ni, nj, k - D), inf);
					}
				}
			}
		}
	}
	cout << max_flow(S, T) << endl;
}

int main()
{
	IOS;
	cin >> P >> Q >> R >> D;
	for (int i = 1; i <= R; i++)
	{
		for (int j = 1; j <= P; j++)
		{
			for (int k = 1; k <= Q; k++)
				cin >> V[j][k][i];
		}
	}
	solve();

	return 0;
}
luoguP4174.最大获利

传送门
题目大意：
N ( N ≤ 5000 ) N(N\leq 5000) N(N≤5000)个基站，每个基站建设成本 P i ( 0 ≤ P i ≤ 100 ) P_{i}(0\leq P_{i}\leq 100) Pi​(0≤Pi​≤100)， M ( M ≤ 50000 ) M(M\leq50000) M(M≤50000)个用户，第 i i i个用户希望使用 A i A_{i} Ai​， B i B_{i} Bi​两个基站，给使用费 C i ( 0 ≤ C i ≤ 100 ) C_{i}(0\leq C_{i}\leq 100) Ci​(0≤Ci​≤100)。可以选择架设若干基站来满足若干用户的建设需求，求最大的收益（费用-成本）。

思路：
考虑获取某个使用费 C i C_{i} Ci​，那么就需要建设 A i , B i A_{i},B_{i} Ai​,Bi​，于是可以从 C i C_{i} Ci​向 A i , B i A_{i},B_{i} Ai​,Bi​连边。每个点有各自的权值，成本为负的，使用费为正的，于是对于所有 C C C如此连边，求这张图的最大权闭合子图即可。

代码：

#include<bits/stdc++.h>
#include<unordered_map>
#include<unordered_set>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
//#define int LL
#define endl '\n'
#define inf 0x3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#pragma warning(disable :4996)
const double eps = 1e-8;
const LL mod = 1000000007;
const LL MOD = 998244353;
const int maxm = 50010;
const int maxn = 5010;

struct edge {
	int to, cap, rev;
};

int N, M;
int P[maxn], A[maxm], B[maxm], C[maxm];
vector<edge>G[maxm * 3];
int level[maxm * 3], iter[maxm * 3];
LL sum = 0;

void add_edge(int from, int to, int cap)
{
	G[from].push_back(edge{ to,cap,(int)G[to].size() });
	G[to].push_back(edge{ from,0,(int)G[from].size() - 1 });
}

void bfs(int s)
{
	memset(level, -1, sizeof(level));
	queue<int> que;
	level[s] = 0;
	que.push(s);
	while (!que.empty())
	{
		int v = que.front();
		que.pop();
		for (int i = 0; i < G[v].size(); i++)
		{
			edge& e = G[v][i];
			if (e.cap > 0 && level[e.to] < 0)
			{
				level[e.to] = level[v] + 1;
				que.push(e.to);
			}
		}
	}
}

int dfs(int v, int t, int f)
{
	if (v == t)
		return f;
	for (int& i = iter[v]; i < G[v].size(); i++)
	{
		edge& e = G[v][i];
		if (e.cap > 0 && level[v] < level[e.to])
		{
			int d = dfs(e.to, t, min(f, e.cap));
			if (d > 0)
			{
				e.cap -= d;
				G[e.to][e.rev].cap += d;
				return d;

			}
		}
	}

	return 0;
}

int max_flow(int s, int t)
{
	int flow = 0;
	while (true)
	{
		bfs(s);
		if (level[t] < 0)
			return flow;
		memset(iter, 0, sizeof(iter));
		int f;
		while ((f = dfs(s, t, INF)) > 0)
			flow += f;
	}

	return flow;
}


void solve()
{
	//1~N:基站1~N
	//N+1~N+M:各获益
	int S = N + M + 1, T = N + M + 2;
	for (int i = 1; i <= N; i++)
		add_edge(i, T, P[i]);
	for (int i = 1; i <= M; i++)
	{
		add_edge(N + i, B[i], inf);
		add_edge(N + i, A[i], inf);
		add_edge(S, N + i, C[i]);
	}
	cout << sum - max_flow(S, T) << endl;
}

int main()
{
	IOS;
	cin >> N >> M;
	for (int i = 1; i <= N; i++)
		cin >> P[i];
	for (int i = 1; i <= M; i++)
	{
		cin >> A[i] >> B[i] >> C[i];
		sum += C[i];
	}
	solve();

	return 0;
}
CF653D.Delivery Bears

传送门
题目大意：
N ( 2 ≤ N ≤ 50 ) N(2\leq N\leq50) N(2≤N≤50)个点， M ( 1 ≤ M ≤ 500 ) M(1\leq M\leq500) M(1≤M≤500)条边的有向图，每条边有重量上限 C i ( 1 ≤ C i ≤ 1 0 6 ) C_{i}(1\leq C_{i}\leq10^6) Ci​(1≤Ci​≤106)，现有 X ( 1 ≤ X ≤ 1 0 5 ) X(1\leq X\leq10^5) X(1≤X≤105)批重量相同的货物，你可以给定任意的重量，但是一批货物必须作为一个整体运送（即不能拆成若干重量更小的货物运送），求能够将全部 X X X批货物从 1 1 1运送到 N N N的时的货物总重量最大为多少。

思路：
显然我们可以二分每批货物的重量 w w w，对于每个 w w w，我们将图中所有的权值由 C i C_{i} Ci​变为 ⌊ C i w ⌋ \lfloor \frac{C_{i}}{w}\rfloor ⌊wCi​​⌋，之后在图中跑最大流，如果 m a x f l o w ≥ X maxflow\geq X maxflow≥X就说明当前重量可行，否则不可行。

代码：

#include<bits/stdc++.h>
#include<unordered_map>
#include<unordered_set>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
//#define int LL
#define endl '\n'
#define inf 0x3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#pragma warning(disable :4996)
const double eps = 1e-8;
const LL mod = 1000000007;
const LL MOD = 998244353;
const int maxv = 60;
const int maxe = 510;

int N, M, X;
LL C[maxe];
int U[maxe], V[maxe];
struct edge {
	int to;
	LL cap;
	int rev;
};
vector<edge> G[maxv];
int level[maxv], iter[maxv];

void add_edge(int from, int to, LL cap)
{
	G[from].push_back(edge{ to,cap,(int)G[to].size() });
	G[to].push_back(edge{ from,0,(int)G[from].size() - 1 });
}

void bfs(int s)
{
	memset(level, -1, sizeof(level));
	queue<int> que;
	level[s] = 0;
	que.push(s);
	while (!que.empty())
	{
		int v = que.front();
		que.pop();
		for (int i = 0; i < G[v].size(); i++)
		{
			edge& e = G[v][i];
			if (e.cap > 0 && level[e.to] < 0)
			{
				level[e.to] = level[v] + 1;
				que.push(e.to);
			}
		}
	}
}

int dfs(int v, int t, LL f)
{
	if (v == t)
		return f;
	for (int& i = iter[v]; i < G[v].size(); i++)
	{
		edge& e = G[v][i];
		if (e.cap > 0 && level[v] < level[e.to])
		{
			LL d = dfs(e.to, t, min(f, e.cap));
			if (d > 0)
			{
				e.cap -= d;
				G[e.to][e.rev].cap += d;
				return d;

			}
		}
	}

	return 0;
}

LL max_flow(int s, int t)
{
	LL flow = 0;
	while (true)
	{
		bfs(s);
		if (level[t] < 0)
			return flow;
		memset(iter, 0, sizeof(iter));
		LL f;
		while ((f = dfs(s, t, INF)) > 0)
			flow += f;
	}

	return flow;
}

bool Check(double w)
{
	for (int i = 1; i <= N; i++)
		G[i].clear();
	for (int i = 1; i <= M; i++)
		add_edge(U[i], V[i], (LL)floor(C[i] / w));

	return max_flow(1, N) >= X;
}

void solve()
{
	double lo = 0, hi = INF;
	for (int i = 1; i <= 100; i++)
	{
		double mid = (lo + hi) / 2;
		if (Check(mid))
			lo = mid;
		else
			hi = mid;
	}
	double ans = lo * X;
	cout << setiosflags(ios::fixed) << setprecision(10) << ans << endl;
}

int main()
{
	IOS;
	cin >> N >> M >> X;
	for (int i = 1; i <= M; i++)
		cin >> U[i] >> V[i] >> C[i];
	solve();

	return 0;
}
luoguP4043.支线剧情

传送门
题目大意：
给定一张 N ( N ≤ 300 ) N(N\leq300) N(N≤300)个点， M ( M ≤ 15000 ) M(M\leq15000) M(M≤15000)的 D A G DAG DAG，每条边上有一个费用，可以从 1 1 1号点出发若干次，每次可以在任意一个点结束，求使将所有边都走过一遍所花费的最小费用。

思路：
建立源点 S S S与汇点 T T T， S S S向 1 1 1连一条容量为 i n f inf inf，费用为 0 0 0的边，表示可以从 1 1 1出发若干次， 1 ∼ N 1\sim N 1∼N每个点向 T T T连容量为 i n f inf inf，费用为 0 0 0的边，表示可以从任意一点结束若干次，对于原图中已经存在的边，连一条容量为 [ 1 , i n f ] [1,inf] [1,inf]，费用为原费用的边，表示所有边至少走 1 1 1次。之后就是要求新图的最小费用可行流，建立超级源点 S S SS SS与超级汇点 S T ST ST，对所有有上界 c c c，下界 b b b的边 ( u , v ) (u,v) (u,v)，从 u u u到 v v v连容量为 c − b c-b c−b的边，从 u u u向 T T TT TT连容量为 1 1 1的边，从 S S SS SS向 v v v连容量为 1 1 1的边，这些边的费用 d d d保持不变，最后再从 T T T向 S S S连一条容量为 i n f inf inf，费用为 0 0 0的边即可。之后求新图的最小费用最大流的费用 − - −所有有上下界的边的费用总和即可。

代码：

#include<bits/stdc++.h>
#include<unordered_map>
#include<unordered_set>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
//#define int LL
#define endl '\n'
#define inf 0x3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#pragma warning(disable :4996)
const double eps = 1e-8;
const LL mod = 1000000007;
const LL MOD = 998244353;
const int maxv = 5010;

struct edge {
	int to, cap, cost, rev;
};

int sum = 0;
int N, SS, TT, S, T;
int V;
vector<edge> G[maxv];
int h[maxv], dist[maxv], prevv[maxv], preve[maxv];

void add_edge(int from, int to, int cap, int cost)
{
	G[from].push_back(edge{ to, cap, cost, (int)G[to].size() });
	G[to].push_back(edge{ from, 0, -cost, (int)G[from].size() - 1 });
}

int min_cost_flow(int s, int t, int f)
{
	int res = 0;
	memset(h, 0, sizeof(h));
	while (f > 0)
	{
		priority_queue<PII, vector<PII>, greater<PII>> que;
		memset(dist, inf, sizeof(dist));
		dist[s] = 0;
		que.push(PII(0, s));
		while (!que.empty())
		{
			PII p = que.top();
			que.pop();
			int v = p.second;
			if (dist[v] < p.first)
				continue;
			for (int i = 0; i < G[v].size(); i++)
			{
				edge& e = G[v][i];
				if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to])
				{
					dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
					prevv[e.to] = v;
					preve[e.to] = i;
					que.push(PII(dist[e.to], e.to));
				}
			}
		}
		if (dist[t] == inf)
			break;
		for (int v = 1; v <= V; v++)
			h[v] += dist[v];
		int d = f;
		for (int v = t; v != s; v = prevv[v])
			d = min(d, G[prevv[v]][preve[v]].cap);
		f -= d;
		res += d * h[t];
		for (int v = t; v != s; v = prevv[v])
		{
			edge& e = G[prevv[v]][preve[v]];
			e.cap -= d;
			G[v][e.rev].cap += d;
		}
	}

	return res;
}

void solve()
{
	cout << min_cost_flow(SS, TT, INT_MAX) - sum << endl;
}

int main()
{
	IOS;
	cin >> N;
	S = N + 1, T = S + 1;
	SS = T + 1, V = TT = SS + 1;
	int k, to, c;
	add_edge(S, 1, inf, 0);
	add_edge(T, S, inf, 0);
	for (int i = 1; i <= N; i++)
	{
		add_edge(i, T, inf, 0);
		cin >> k;
		for (int j = 1; j <= k; j++)
		{
			cin >> to >> c;
			sum += c;
			add_edge(i, to, inf - 1, c);
			add_edge(SS, to, 1, c);
			add_edge(i, TT, 1, c);
		}
	}
	solve();

	return 0;
}
luoguP3980.志愿者招募

传送门
题目大意：
一向工作持续 N ( 1 ≤ N ≤ 1000 ) N(1\leq N\leq1000) N(1≤N≤1000)天，共有 M ( 1 ≤ M ≤ 10000 ) M(1\leq M\leq10000) M(1≤M≤10000)类志愿者，每个志愿者有属性 s i , t i , c i s_{i},t_{i},c_{i} si​,ti​,ci​，表示第 i i i类志愿者在 [ s i , t i ] [s_{i},t_{i}] [si​,ti​]这段时间内参与工作，招募一名该类志愿者需要花费 c i c_{i} ci​元，每个日期 i i i需要的志愿者总数至少为 A i A_{i} Ai​，求最少花费。

思路：
我们设第 i i i天参与工作的志愿者总数为 P i P_{i} Pi​，招募的第 j j j类志愿者总数为 X j X_{j} Xj​，设第 j j j类志愿者是否可以在第 i i i天工作为 m i j m_{ij} mij​，于是有 P i = ∑ m i j = 1 X j ≥ A i P_{i}=\sum_{m_{ij}=1} X_{j}\geq A_{i} Pi​=∑mij​=1​Xj​≥Ai​，我们设 Y i Y_{i} Yi​为第 i i i天多招募的人数，因此 A i = ∑ m i j = 1 X j − Y i A_{i}=\sum_{m_{ij}=1} X_{j}-Y_{i} Ai​=∑mij​=1​Xj​−Yi​，我们可以得到这样的 N N N个等式。

之后我们对它们做差分，设 A 0 = A N + 1 = 0 A_{0}=A_{N+1}=0 A0​=AN+1​=0，求出所有的 A i − A i − 1 ( 1 ≤ i ≤ N + 1 ) A_{i}-A_{i-1}(1\leq i\leq N+1) Ai​−Ai−1​(1≤i≤N+1)，又对于每类志愿者，其工作时间是连续的一段，因此，每个 X j X_{j} Xj​也是在连续的一段等式中所出现的，因此在差分后的 N + 1 N+1 N+1个等式中， X j X_{j} Xj​与 − X j -X_{j} −Xj​各仅出现 1 1 1次。同时可以发现， Y i Y_{i} Yi​与 − Y i -Y_{i} −Yi​也各仅出现 1 1 1次。我们可以把这每个等式两侧当成一个节点的流出与流入。这样我们可以为每个等式建立一个节点来建图：

对于每个节点 i i i，我们将等式左侧的 A i − A i − 1 A_{i}-A_{i-1} Ai​−Ai−1​作为其流入，从源点 S S S向其连一条容量为 A i − A i − 1 A_{i}-A_{i-1} Ai​−Ai−1​费用为 0 0 0的边（如果值为负数，改为向汇点 T T T连容量为相反数的边），将等式右侧作为流出，由于签面提到的 X , Y X,Y X,Y的性质，我们可对每个 X , Y X,Y X,Y仅需对应连一条边（仅对应一个流入和流出），对于每个 X i X_{i} Xi​，我们连一条从 s i s_{i} si​到 t i + 1 t_{i}+1 ti​+1连一条容量为 i n f inf inf，费用为 c i c_{i} ci​的边表示 X i X_{i} Xi​；而对于每个 Y i Y_{i} Yi​，我们连一条从 i i i到 i − 1 i-1 i−1连一条容量为 i n f inf inf，费用为 0 0 0的边表示 Y i − 1 Y_{i-1} Yi−1​。之后对这样的一张图求最小费用最大流即可。

代码：

#include<bits/stdc++.h>
#include<unordered_map>
#include<unordered_set>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
//#define int LL
#define endl '\n'
#define inf 0x3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#pragma warning(disable :4996)
const double eps = 1e-8;
const LL mod = 1000000007;
const LL MOD = 998244353;
const int maxv = 1010;
const int maxn = 1010;

struct edge {
	int to, cap, cost, rev;
};

int sum = 0;
int N, M, S, T;
int V;//顶点数
int A[maxn];
vector<edge> G[maxv];
int h[maxv], dist[maxv], prevv[maxv], preve[maxv];

void add_edge(int from, int to, int cap, int cost)
{
	//cout << from << "__" << to << "___" << cap << "__" << cost << endl;
	G[from].push_back(edge{ to, cap, cost, (int)G[to].size() });
	G[to].push_back(edge{ from, 0, -cost, (int)G[from].size() - 1 });
}

int min_cost_flow(int s, int t, int f)
{
	int res = 0;
	memset(h, 0, sizeof(h));
	while (f > 0)
	{
		priority_queue<PII, vector<PII>, greater<PII>> que;
		memset(dist, inf, sizeof(dist));
		dist[s] = 0;
		que.push(PII(0, s));
		while (!que.empty())
		{
			PII p = que.top();
			que.pop();
			int v = p.second;
			if (dist[v] < p.first)
				continue;
			for (int i = 0; i < G[v].size(); i++)
			{
				edge& e = G[v][i];
				if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to])
				{
					dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
					prevv[e.to] = v;
					preve[e.to] = i;
					que.push(PII(dist[e.to], e.to));
				}
			}
		}
		if (dist[t] == inf)
			break;
		for (int v = 1; v <= V; v++)
			h[v] += dist[v];
		int d = f;
		for (int v = t; v != s; v = prevv[v])
			d = min(d, G[prevv[v]][preve[v]].cap);
		f -= d;
		res += d * h[t];
		for (int v = t; v != s; v = prevv[v])
		{
			edge& e = G[prevv[v]][preve[v]];
			e.cap -= d;
			G[v][e.rev].cap += d;
		}
	}

	return res;
}

void solve()
{
	cout << min_cost_flow(S, T, inf) << endl;
}

int main()
{
	IOS;
	cin >> N >> M;
	S = N + 2, V = T = S + 1;
	for (int i = 1; i <= N; i++)
	{
		cin >> A[i];
		int k = A[i] - A[i - 1];
		if (k > 0)
			add_edge(S, i, k, 0);
		else
			add_edge(i, T, -k, 0);
		add_edge(i + 1, i, inf, 0);
	}
	add_edge(N + 1, T, A[N], 0);
	int s, t, c;
	for (int i = 1; i <= M; i++)
	{
		cin >> s >> t >> c;
		add_edge(s, t + 1, inf, c);
	}
	solve();

	return 0;
}
Prgl
关注
AHUACM寒假集训I（基础数据结构+串串）
Prgl的博客
01-14 252
H.超级钢琴 luoguP2048 题目大意：求出一个长N序列中所有长度在L到R的子序列中序列和最大的K个，并求这K个的和 思路：暴力的话可以求出所有满足要求的子序列然后排序，然后显然会T。 所以我们可以考虑对最大值一个个求解，求出一个最大值后删去之，继续求剩下的里面的最大值，总共求出K个即可。 我们先做一个前缀和，然后枚举左端点S[i]S[i]S[i]，右端点S[j]S[j]S[j]在一个区间内，我们可以求出右端点的最大值也就能求出当前左端点下的最大值，我们把每个左端点这样求出的值加入堆内，然后我们弹出了
AOJ-AHU-OJ-2 Homework
JSure的代码库
03-01 3426
Home Work Time Limit: 1000 ms   Case Time Limit: 1000 ms   Memory Limit: 64 MB Description 临近开学了，大家都忙着收拾行李准备返校，但I_Love_C却不为此担心! 因为他的心思全在暑假作业上：目前为止还未开动(-_-!!还以为他有多冷静呢)。暑假作业是很多张试卷，我们这些从试卷里爬出来的人都知道，
AHUACM寒假集训II（线段树）
Prgl的博客
01-13 158
AHUACM寒假集训II（线段树） B.Mayor’s posters POJ2528 题目大意： D.Count Color POJ2777 题目大意：长为L(L≤105)L( L\leq10^5)L(L≤105)的序列，每个点上可以有T(T≤30)T(T\leq30)T(T≤30)种颜色以供染色（整个序列最开始都为颜色1），O(O≤105)O(O\leq10^5)O(O≤105)次操作： CCC aaa bbb ccc：[a,b][a,b][a,b]染上颜色ccc PPP aaa bbb：查询[a,b]
2023寒假集训通知
hsyoi的博客
01-02 671
2023 寒假 编程 报名
寒假集训总结
johsnows的博客
02-27 672
寒假的训练以不太顺利的结果结束。整个寒假训练都是两天一场学长抓的训练赛，然后补题，由于自己比较菜以及一些莫名的因素，导致训练赛打得比较差，尤其是后几场。训练赛没能打好的原因可能与状态关系确实很大，但其中肯定与实力有关吧。总结一下，这些题目，算法和思维上难倒自己的好像也没几道(后来补出来的)，但是赛场中有很多因素导致自己没能发挥出来。 第一：最重要的就是代码能力。有很多题目自己能想到解法，但是在代
2016 寒假集训有感
I good vegetable a!
01-14 1365
不知道什么时候开始，ACM已经在自己的脑子里，成为了和吃饭一样不可缺少的东西。2016ACM教会了我太多东西，今天突然想写一点感想之类东西了。 不知道为什么，除了和集训队这群人以及队友玩得非常贴合之外，和室友和其他的身边男生关系却处得很差，或许是性格不合，或许是不和他们一起玩游戏，或许他们也觉得我很SB吧。喜欢ACM，喜欢这种竞赛的环境，喜欢突然AC一道题的感觉。2016青岛之战，勉强拿了块铜牌回来
2022牛客寒假算法基础集训营1
SecretMas的博客
03-07 4059
A 九小时九个人九扇门 题意： 给定n个正整数，分别计算出数字根为1—9的组合数 涉及算法：数字根，线性dp 数字根： 将一正整数的各个位数相加(即横向相加)后，若加完后的值大于等于10的话，则继续将各位数进行横向相加直到其值小于十为止所得到的数，即为数字根。 性质一： 两个正整数相加，原来两个数的数字根之和等于和的数字根。 性质二： 设一个正整数为 x，则其数字根为 (x - 1) % 9 + 1。 由数字根的性质二，数字根求解的核心代码： int f (int x) { return (x - 1
2024牛客寒假算法基础集训营1
m0_74176921的博客
02-02 2303
首先对于一个满减 ,满 a1 减 b1 ，如果另外一个满减，满 a2 减 b2 ,如果满足 a2>=a1，那么如果购买的金额 大于 a2 的时候，所获得的减免就是 b1+b2 ,于是我们想到先减免要求价格从小到大排序一下，利用前缀和记录 bi ,于是便获得了大于某个价格的最大减免，由于要求得是能购买的最大值，于是我们可以从减免要求价格从大往下开始遍历，如果当前价格减去减免额之后小于给定的 m ，说明是合法的，最终的原价就是 m+ 减免额。同时榜单上还有"向左"按钮与"向右"按钮来切换显示的题目。
寒假集训D2
NCWUACM的博客
12-29 3566
学习目标： 并查集，线段树 学习内容： 1.并查集用来实现集合的合并与查找，用树来存储一个集合如果两个点有共同的根，他们就在一个集合里，合并两个点所在集合只需要把一个点的根接到另一个点的根下面就行。 1）一般模板 2）基础问题描述 3）带权并查集 4）扩展域并查集 5）练习题目：基础题(必做)+提高题 2.线段树(Segment Tree)是用一种树状结构来存储一个连续区间的信息的数据结构。它主要用于处理一段连续区间的插入、查找、统计、查询等操作。复杂度： 设区间长度是n，所有操作的复杂度
matlab集成c代码-2021-IFR-WinterTraining:2021寒假集训每日进度
05-22
2021寒假集训每日进度 1.6 回顾单个电机控制代码，封装函数使代码更简洁并完成遥控器对电机控制的模式切换与看门狗。 1.7 完成编写并封装4麦轮步兵底盘代码（函数名称前缀My），待测试。 1.8 学习、复习C语言，测试4...
2013年heu寒假集训练习赛AK--第3场
01-23
`~scanf`的使用是一种常见的技巧，用来检查输入流是否结束。 ### 1002：多变量处理与复杂计算 此段代码更复杂，它不仅读取四个整数，还进行了一系列复杂的条件判断和数学运算。主要涉及到了C++中的标准命名空间`...
LSNU寒假集训 题解
热门推荐
你的代码 受命于你
01-13 1万+
目录 LSNU寒假第一场（基础算法+几何） A - Fifa and Fafa B - Anton and Lines C - Minimum path D - Thematic Contests E - Balanced Playlist F - Median String G - String Reconstruction H - Palindrome Pairs L...
字节序（Byte Order）
weixin_50993868的博客
11-11 248
字节序与平台字节序转换字节序（Byte Order）是指数据在内存中存储时字节的排列顺序。由于不同的计算机体系结构可能采用不同的字节序，因此理解字节序非常重要，特别是在处理多平台数据传输或存储时。
AnaTraf | 巧用网络流量分析技术，守护网络 “健康”
最新发布
Johnstons的博客
11-13 131
这时候，借助流量分析工具查看流量情况，若是发现某条链路的流量出现了异常的高峰，远超正常的带宽承载能力，那很可能就是这条链路出现了拥塞问题，或许是有设备在疯狂发送大量无用的数据，导致网络 “交通堵塞”。比如，长期观察发现某个区域的网络节点总是出现流量高峰，而当前的网络带宽配置又不足以应对这样的高峰，那我们就可以针对性地进行带宽升级，或者调整网络拓扑结构，进行流量的合理分流，让数据能够更加顺畅地在网络中 “流淌”。网络流量分析技术，简单来说，就是对网络中流动的数据进行监测、收集、解析以及统计的技术手段。
UNIX 域套接字
weixin_50993868的博客
11-12 299
UNIX 域套接字（UNIX Domain Socket，简称 UDS）是一种在同一台机器上的进程间通信（IPC，Inter-Process Communication）机制，允许不同的进程通过文件系统中的特殊文件进行数据交换，而不需要通过网络协议栈。这使得 UNIX 域套接字在本地通信中比传统的 TCP/IP 套接字更高效。流式数据：和 TCP 套接字类似，UNIX 域套接字也支持面向流的通信（SOCK_STREAM），以及无连接的报文通信（SOCK_DGRAM）。// 套接字文件的路径。
【网络安全 | 漏洞挖掘】隐藏的 DOS 技术
等风来
11-11 333
我调查了这些参数的用途，发现它们被传递给了第三方服务，且该服务的文档说明这些参数是安全的。你可以试试这样做：前往https://ash-speed.hetzner.com/并找到一个测试文件（大小大约1到10 GB），如果服务器等待URL请求完成，你可以通过大量此类请求来淹没服务器，从而导致它最终崩溃。于是我发送了一个包含1000个UUID的列表，结果网站在60秒后超时，并出现了显著的延迟。在我的案例中，这导致了客户网站的DOS攻击，问题被发现并快速修复，甚至在我报告漏洞之前。
Tcp/Ip协议，tcp相关文章，网络编程，通信协议文章汇总
求是
11-10 347
都是网络协议相关的，tcp/ip, arp, dhcp, icmp, http。学习时候，有些书籍过一段时间就忘记了。常读常新，特此留下地址方便再次阅读！4.如果你喜欢看视频。1. tcp/ip 协议卷。2.不为人知的网络编程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值