4.26总结

AT_abc328_e

其实看起来复杂，实际上只要dfs枚举每一边，在最后判断是否为生成树，计算贡献即可

点击查看代码

#include<bits/stdc++.h>
#define int long long
#define endl "\n"
using namespace std;
const int maxn=1e6+5,mod=1e9+7,inf=1e18;
int read(){int x=0,f=1;char ch=getchar();while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}while(ch>='0' && ch<='9')x=x*10+ch-'0',ch=getchar();return x*f;}
void write(int x){if(x<0){putchar('-'),x=-x;}if(x>9){write(x/10);}putchar(x%10+'0');return;}
int fpow(int a,int b,int p){if(b==0){return 1;}int res=fpow(a,b/2,p)%p;if(b%2==1){return((res*res)%p*a)%p;}else{return(res*res)%p;}}
int n,m,k,fa[maxn],ans=1e9,vis[maxn],res[maxn];
struct Node{
	int u,v,w;
}edge[maxn];
int find(int x){
	if(fa[x]==x){
		return x;
	}
	return find(fa[x]);
}
void uniset(int x,int y){
	x=find(x);
	y=find(y);
	if(x!=y){
		fa[x]=y;
	}
}
bool check(){
	for(int i=1;i<=n;i++){
		fa[i]=i;
	}
	for(int i=1;i<=n;i++){
		if(find(edge[res[i]].u)!=find(edge[res[i]].v)){
			uniset(edge[res[i]].u,edge[res[i]].v);
		}
		else{
			return 0;
		}
	}
	return 1;
}
void dfs(int x,int sum){
	if(x==n){
		if(!check()){
			return ;
		}
		ans=min(ans,sum%k);
		return;
	}
	for(int v=res[x-1]+1;v<=m;v++){
		if(vis[v]==0){
			vis[v]=1;
			res[x]=v;
			dfs(x+1,(sum+edge[v].w)%k);
			vis[v]=0;
		}
	}
}
signed main(){
	cin>>n>>m>>k;
	
	for(int i=1;i<=m;i++){
cin>>edge[i].u>>edge[i].v>>edge[i].w;	}
	dfs(1,0);
	cout<<ans;
	return 0;
}

芒果的能源计划

题解：U556262 芒果的能源计划

题目分析

题目描述了一个能源分配问题。我们有n个城市，m条道路，每条道路可以连接两个城市。每条道路可以被它连接的两个城市中的一个的能源核心激活，但每个能源核心只能激活一条道路。我们的目标是选择一组道路，使得所有能源核心都被使用，并且拨款总额最大。

解题思路

这个问题可以转化为一个图论问题，我们需要找到一个子图，满足：

1. 每个城市（节点）最多有一条出边
2. 子图的边权和最大

这实际上是一个最大生成森林问题，其中每个连通分量是一棵树加上可能的额外边。具体来说，我们需要选择边，使得在每个连通块中，边数不超过节点数减1（即树的性质），同时最大化总权重。

算法选择

我们可以使用贪心算法结合并查集数据结构来解决这个问题：

1. 将所有边按权重从大到小排序
2. 使用并查集来维护连通分量
3. 对于每条边，检查它是否可以加入当前图中而不违反约束条件：
   • 如果边的两个端点在同一连通块中，检查该块是否还能添加更多边（边数 < 节点数）
   • 如果边的两个端点在不同连通块中，检查至少一个块还能添加更多边

代码实现

代码的主要部分包括：

1. 并查集：用于高效管理连通分量
2. 贪心选择：按权重降序处理边
3. 约束检查：确保每个连通分量中的边数不超过节点数减1

样例解释

以第一个测试用例为例：

• 排序后权重为7,7,6,2,2,2,1
• 选择权重7的两条边和权重6的边，总和为20
• 这样三个城市的能源核心都被使用，且总拨款最大

代码

#include<bits/stdc++.h>
#define int long long
#define endl "\n"
using namespace std;
const int maxn=1e6+5,mod=1e9+7,inf=1e18;
int read(){int x=0,f=1;char ch=getchar();while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}while(ch>='0' && ch<='9')x=x*10+ch-'0',ch=getchar();return x*f;}
void write(int x){if(x<0){putchar('-'),x=-x;}if(x>9){write(x/10);}putchar(x%10+'0');return;}
int fpow(int a,int b,int p){if(b==0){return 1;}int res=fpow(a,b/2,p)%p;if(b%2==1){return((res*res)%p*a)%p;}else{return(res*res)%p;}}
struct Node{
    int u,v,w;
}edge[maxn];
int t,n,m,fa[maxn],edges[maxn],node[maxn];
int a[maxn];
int find(int x){
    if(fa[x]==x){
        return x;
    }
    return fa[x]=find(fa[x]);
}
bool cmp(Node x,Node y){
    return x.w>y.w;
}
void solve(){
    cin>>n>>m;
    int ans=0;
    for(int i=1;i<=n;i++){
        fa[i]=i;
        edges[i]=0;
        node[i]=1;
    }
    for(int i=1;i<=m;i++){
        cin>>edge[i].u>>edge[i].v>>edge[i].w;
    }
    sort(edge+1,edge+1+m,cmp);
    for(int i=1;i<=m;i++){
        int u=find(edge[i].u);
        int v=find(edge[i].v);
        if(u==v){
            if(edges[u]<node[u]){
                edges[u]++;
                ans+=edge[i].w;
            }
        }
        else{
            if(edges[u]<node[u]||edges[v]<node[v]){
                fa[u]=v;
                edges[v]+=edges[u];
                node[v]+=node[u];
                ans+=edge[i].w;
                edges[v]++;
            }
        }
    }
    cout<<ans<<endl;
}
signed main(){
    cin>>t;
    while(t--){
        solve();
    }
    return 0;
}