【JZOJ3317】管道

Hotham市的供水系统遭到Jester的袭击,其管道网络受到破坏。每个水库的水量变化取决于连接的管道排水和注水量。问题在于根据水库的净变化判断是否有唯一方案确定每条管道的排水和注水量。当图形成一棵树或特定环状结构时,可以使用特定算法找出唯一解。文章分析了问题的解决方案并提供了代码实现。

description

Hotham市再次被Jester袭击。这一次,Jester攻击的目标是Hotham的供水系统。Hotham的淡水存储在N个水库,由M个管道连接。

任意2个水库之间至少有一条路径,该路径可能包含多个管道。每个管道连接两个不同的水库,任何两个水库之间最多只有一个管道。Jester破坏了一些管道进行排水。管道的排水量为偶数立方米/秒。如果连接水库u和水库v的管道排水量为2D立方米/秒,那么水库u和水库v排水量分别为D立方米/秒。Jester可以也破坏一些管道进行注水。同样,连接水库u和v的管道注入水量为2P立方米/秒,则水库u和水库v注水量分别为P立方米/秒。

每个水库供水量的净变化是由连接到它的管道的排水量和注水量的总和。如果连接该水库的管道排水量分别为2D1, 2D2,…,2Da立方米/秒, 注水量分别为2P1, 2P2 ,…,2Pb 立方米/秒。该水库水量的净变化为P1 + P2 + … + Pb -D1 - D2 –Da。

Hotham市长已在水库安装了传感器,但不是在管道中。因此,他可以观察到在每个水库水的净变化,但并知道有多少水被排出或注入各个管道。

给出水管连接图和每个水库供水量的净变化,编写程序决定这些信息是否能确定一个唯一的计划。如果各个水管排出或注入的水量是唯一的,那么该计划可以被唯一确定。请注意,并不是每一个水管中的注水量和排水量都相等。如果恰好有一个可能性,你的程序应该打印出来。


analysis

  • 可以知道这个东西列出来就像方程组一样,所以m&lt;n−1m&lt;n-1m<n1m&gt;nm&gt;nm>n无解

  • 当图为一棵树时,从叶子节点向上推,肯定有唯一解

  • 当图为基环树时,tarjantarjantarjan缩点,若环为偶环则无解

  • 奇环则先遍历环内每一个点为根的子树,把不在该环上的点去掉并计算贡献

  • 然后可以知道边权和为点权和的一半,再减去该环上相隔的点的权值,最后剩下的即为最后一条边的边权

  • 知道了一条边权就可以把整个环的边权求出来码量不大极易理解


code

#include<stdio.h>
#include<string.h>
#include<algorithm>
#define ll long long
#define MAXN 200005
#define MAXM MAXN*5
#define fo(i,a,b) for (ll i=a;i<=b;++i)
#define fd(i,a,b) for (ll i=a;i>=b;--i)
#define rep(i,a) for (ll i=last[a];i;i=next[i])

using namespace std;

ll last[MAXM],next[MAXM],tov[MAXM],id[MAXN];
ll dfn[MAXN],low[MAXN],stack[MAXN],color[MAXN];
ll a[MAXN],b[MAXN],c[MAXN],d[MAXN][2];
ll val[MAXN],fa[MAXN],size[MAXN];
ll n,m,tot,total,type;
bool bz[MAXN];

inline ll read()
{
	ll x=0,f=1;char ch=getchar();
	while (ch<'0' || '9'<ch){if (ch=='-')f=-1;ch=getchar();}
	while ('0'<=ch && ch<='9')x=x*10+ch-'0',ch=getchar();
	return x*f;
}
inline void link(ll x,ll y,ll z)
{
	next[++tot]=last[x],last[x]=tot,tov[tot]=y,id[tot]=z;
}
inline void dfs(ll x,ll y)
{
	bool flag=1;
	rep(i,x)if (tov[i]!=y)
	{
		dfs(tov[i],x),a[id[i]]=val[tov[i]]*2;
		val[x]-=val[tov[i]];
	}
}
inline void tarjan(ll x,ll y)
{
	dfn[x]=low[x]=++tot;
	stack[++stack[0]]=x,bz[x]=1;
	rep(i,x)if (tov[i]!=y)
	{
		if (!dfn[tov[i]])tarjan(tov[i],x),low[x]=min(low[x],low[tov[i]]);
		else if (bz[tov[i]])low[x]=min(low[x],dfn[tov[i]]);
	}
	if (low[x]==dfn[x])
	{
		++total;
		for (;stack[stack[0]+1]!=x;--stack[0])
		{
			ll tmp=stack[stack[0]];
			color[tmp]=total,bz[tmp]=0;
		}
	}
}
inline void dfs1(ll x,ll xx)
{
	bz[x]=0;
	rep(i,x)if (color[tov[i]]!=type && bz[tov[i]])
	dfs1(tov[i],xx),a[id[i]]=val[tov[i]]*2,val[x]-=val[tov[i]];
}
inline void dfs2(ll x)
{
	bz[x]=0,d[++total][0]=x;
	if (total<c[0])
	{
		rep(i,x)if (color[tov[i]]==type && bz[tov[i]])d[total][1]=id[i],dfs2(tov[i]);
	}
	else 
	{
		rep(i,x)if (color[tov[i]]==type && tov[i]==d[1][0]){d[total][1]=id[i];return;}
	}
}
inline void work()
{
	for (ll i=1;i<total;i+=2)tot-=val[d[i][0]];
	a[d[total-1][1]]=tot,a[d[total][1]]=val[d[total][0]]-tot;
	fd(i,total-2,1)a[d[i][1]]=val[d[i+1][0]]-a[d[i+1][1]];
	fo(i,1,total)a[d[i][1]]*=2;
}
int main()
{
	n=read(),m=read();
	fo(i,1,n)val[i]=read();
	fo(i,1,m)
	{
		ll x=read(),y=read();
		link(x,y,i),link(y,x,i);
	}
	if (m==n-1)
	{
		dfs(1,0);
		fo(i,1,m)printf("%lld\n",a[i]);
		return 0;
	}
	if (m<n-1 || m>n){printf("0\n");return 0;}
	tot=0,memset(bz,0,sizeof(bz)),tarjan(1,0);
	fo(i,1,n)
	{
		++b[color[i]];
		if (b[color[i]]>1){type=color[i];break;}
	}
	memset(bz,1,sizeof(bz));
	fo(i,1,n)if (type==color[i])fa[i]=0,dfs1(i,i),c[++c[0]]=i;
	if (c[0]%2==0){printf("0\n");return 0;}
	memset(bz,0,sizeof(bz)),tot=0;
	fo(i,1,c[0])tot+=val[c[i]],bz[c[i]]=1;
	tot/=2,total=0,dfs2(c[1]),work();
	fo(i,1,m)printf("%lld\n",a[i]);
	return 0;
}
### 解题思路 题目要求解决的是一个与图相关的最小覆盖问题,通常在特定条件下可以通过状态压缩动态规划(State Compression Dynamic Programming, SCDP)来高效求解。由于状态压缩的适用条件是状态维度较小(例如K≤10),因此可以利用二进制表示状态集合,从而优化计算过程。 #### 1. 状态表示 - 使用一个整数 `mask` 表示当前选择的点集,其中第 `i` 位为 `1` 表示第 `i` 个节点被选中。 - 定义 `dp[mask]` 表示在选中 `mask` 所代表的点集后,能够覆盖的节点集合。 - 可以通过预处理每个点的邻域信息(包括自身和所有直接连接的点),快速更新状态。 #### 2. 预处理邻域 对于每个节点 `u`,预先计算其邻域范围 `neighbor[u]`,即从该节点出发一步能到达的所有节点集合。这样,在后续的状态转移过程中,可以直接使用这些信息进行合并操作。 #### 3. 状态转移 - 初始化:对每个单独节点 `u`,设置初始状态 `dp[1 << u] = neighbor[u]`。 - 转移规则:对于任意两个状态 `mask1` 和 `mask2`,如果它们没有交集,则可以通过合并这两个状态得到新的状态 `mask = mask1 | mask2`,并更新对应的覆盖范围为 `dp[mask1] ∪ dp[mask2]`。 - 在所有状态生成之后,检查是否某个状态的覆盖范围等于全集(即覆盖了所有节点)。如果是,则记录此时使用的最少节点数量。 #### 4. 最优解提取 遍历所有可能的状态,找出能够覆盖整个图的最小节点数目。 --- ### 时间复杂度分析 - 状态总数为 $ O(2^K) $,其中 `K` 是关键点的数量。 - 每次状态转移需要枚举所有可能的子集组合,复杂度为 $ O(2^K \cdot K^2) $。 - 整体时间复杂度控制在可接受范围内,适用于 `K ≤ 10~20` 的情况。 --- ### 代码实现(状态压缩 DP) ```cpp #include <bits/stdc++.h> using namespace std; const int MAXN = 25; int neighbor[MAXN]; // 每个节点的邻域 int dp[1 << 20]; // dp[mask] 表示选中的点集合为 mask 时所能覆盖的点集合 int min_nodes; // 最小覆盖点数 void solve(int n, vector<vector<int>>& graph) { // 预处理每个节点的邻域 for (int i = 0; i < n; ++i) { neighbor[i] = (1 << i); // 包括自己 for (int j : graph[i]) { neighbor[i] |= (1 << j); } } // 初始化 dp 数组 memset(dp, 0x3f, sizeof(dp)); for (int i = 0; i < n; ++i) { dp[1 << i] = neighbor[i]; } // 状态转移 for (int mask = 1; mask < (1 << n); ++mask) { if (__builtin_popcount(mask) >= min_nodes) continue; // 剪枝 for (int sub = mask & (mask - 1); sub; sub = (sub - 1) & mask) { int comp = mask ^ sub; if (comp == 0) continue; int new_mask = mask; int covered = dp[sub] | dp[comp]; if (covered == (1 << n) - 1) { min_nodes = min(min_nodes, __builtin_popcount(new_mask)); } dp[new_mask] = min(dp[new_mask], covered); } } } int main() { int n, m; cin >> n >> m; vector<vector<int>> graph(n); for (int i = 0; i < m; ++i) { int u, v; cin >> u >> v; graph[u].push_back(v); graph[v].push_back(u); // 无向图 } min_nodes = n; solve(n, graph); cout << "Minimum nodes required: " << min_nodes << endl; return 0; } ``` --- ### 优化策略 - **剪枝**:当当前状态所用节点数已经超过已知最优解时,跳过后续计算。 - **提前终止**:一旦发现某个状态覆盖了全部节点,并且节点数达到理论下限,即可提前结束程序。 - **空间优化**:可以仅保存当前轮次的状态,减少内存占用。 --- ### 总结 本题通过状态压缩动态规划的方法,将原本指数级复杂度的问题压缩到可接受范围内。结合位运算技巧和预处理机制,能够高效地完成状态转移和覆盖判断操作。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值