hdu 4756 & hdu 4126 & hdu 4081 （prim 次小生成树变形

最新推荐文章于 2020-11-19 13:14:47 发布
最新推荐文章于 2020-11-19 13:14:47 发布
阅读量210 收藏
点赞数
分类专栏： prim

这三个题思路都差不多，问题都是先要求一个最小生成树，然后删掉一条边，询问剩下的最小生成树的情况（距离或者两点权值和之类的）。方法基本都是这样的：求完最小生成树以后，用dp[u][v]表示把最小生成树的边(u,v)切断以后，在两个子树中连某条边能得到的最好情况（这里以删除一条边以后剩下最小生成树的权值为例吧）。以一个点p为父节点，然后对于一条边(u,v)，可以算出v及v的子树中某一点和p连边能获得的最小权值。这样将n个点都搜一遍就行了，然后根据题中的意思进行计算结果就行了。

转自：https://blog.youkuaiyun.com/qian99/article/details/11986635

 

hdu 4756

///                 .-~~~~~~~~~-._       _.-~~~~~~~~~-.
///             __.'              ~.   .~              `.__
///           .'//                  \./                  \\`.
///        .'//                     |                     \\`.
///       .'// .-~"""""""~~~~-._     |     _,-~~~~"""""""~-. \\`.
///     .'//.-"                 `-.  |  .-'                 "-.\\`.
///   .'//______.============-..   \ | /   ..-============.______\\`.
/// .'______________________________\|/______________________________`.
//#pragma GCC optimize("Ofast")
#pragma comment(linker, "/STACK:102400000,102400000")
//#pragma GCC target(sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx) 
#include <vector>
#include <iostream>
#include <string>
#include <map>
#include <stack>
#include <cstring>
#include <queue>
#include <list>
#include <stdio.h>
#include <set>
#include <algorithm>
#include <cstdlib>
#include <cmath>
#include <iomanip>
#include <cctype>
#include <sstream>
#include <functional>
#include <stdlib.h>
#include <time.h>
#include <bitset>
using namespace std;

#define pi acos(-1)
#define s_1(x) scanf("%d",&x)
#define s_2(x,y) scanf("%d%d",&x,&y)
#define s_3(x,y,z) scanf("%d%d%d",&x,&y,&z)
#define s_4(x,y,z,X) scanf("%d%d%d%d",&x,&y,&z,&X)
#define S_1(x) scan_d(x)
#define S_2(x,y) scan_d(x),scan_d(y)
#define S_3(x,y,z) scan_d(x),scan_d(y),scan_d(z)
#define PI acos(-1)
#define endl '\n'
#define srand() srand(time(0));
#define me(x,y) memset(x,y,sizeof(x));
#define foreach(it,a) for(__typeof((a).begin()) it=(a).begin();it!=(a).end();it++)
#define close() ios::sync_with_stdio(0); cin.tie(0);
#define FOR(x,n,i) for(int i=x;i<=n;i++)
#define FOr(x,n,i) for(int i=x;i<n;i++)
#define fOR(n,x,i) for(int i=n;i>=x;i--)
#define fOr(n,x,i) for(int i=n;i>x;i--)
#define W while
#define sgn(x) ((x) < 0 ? -1 : (x) > 0)
#define bug printf("***********\n");
#define db double
#define ll long long
#define mp make_pair
#define pb push_back
#define pf printf
typedef long long LL;
typedef pair <int, int> ii;
const int INF=0x3f3f3f3f;
const LL LINF=0x3f3f3f3f3f3f3f3fLL;
const int dx[]={-1,0,1,0,1,-1,-1,1};
const int dy[]={0,1,0,-1,-1,1,-1,1};
const int maxn=1e3+5;
const int maxx=3e5+10;
const double EPS=1e-8;
const double eps=1e-8;
const int mod=1e9+7;
template<class T>inline T min(T a,T b,T c) { return min(min(a,b),c);}
template<class T>inline T max(T a,T b,T c) { return max(max(a,b),c);}
template<class T>inline T min(T a,T b,T c,T d) { return min(min(a,b),min(c,d));}
template<class T>inline T max(T a,T b,T c,T d) { return max(max(a,b),max(c,d));}
template <class T>
inline bool scan_d(T &ret){char c;int sgn;if (c = getchar(), c == EOF){return 0;}
while (c != '-' && (c < '0' || c > '9')){c = getchar();}sgn = (c == '-') ? -1 : 1;ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9'){ret = ret * 10 + (c - '0');}ret *= sgn;return 1;}

inline bool scan_lf(double &num){char in;double Dec=0.1;bool IsN=false,IsD=false;in=getchar();if(in==EOF) return false;
while(in!='-'&&in!='.'&&(in<'0'||in>'9'))in=getchar();if(in=='-'){IsN=true;num=0;}else if(in=='.'){IsD=true;num=0;}
else num=in-'0';if(!IsD){while(in=getchar(),in>='0'&&in<='9'){num*=10;num+=in-'0';}}
if(in!='.'){if(IsN) num=-num;return true;}else{while(in=getchar(),in>='0'&&in<='9'){num+=Dec*(in-'0');Dec*=0.1;}}
if(IsN) num=-num;return true;}

void Out(LL a){if(a < 0) { putchar('-'); a = -a; }if(a >= 10) Out(a / 10);putchar(a % 10 + '0');}
void print(LL a){ Out(a),puts("");}
//freopen( "in.txt" , "r" , stdin );
//freopen( "data.txt" , "w" , stdout );
//cerr << "run time is " << clock() << endl;

int flag[maxn],head[maxn],pre[maxn],vis[maxn][maxn];
db dis[maxn][maxn],dp[maxn][maxn];
db sum,low[maxn];
int num;
ii Q[maxn];
struct node {
	int to,next;
}e[maxx];

int n,k;

void build(int s, int t){
    e[num].to=t;
    e[num].next=head[s];
    head[s]=num++;
}


void init() {
	sum=0,num=0;
	me(flag,0);
	me(vis,0);
	me(head,-1);
	me(dp,0);
}
void prim()
{
    int i, j;
    for(i = 1; i <= n; i ++)
    {
        low[i] = dis[1][i];
        pre[i] = 1;
    }
    flag[1] = 1;
    for(i = 1; i < n; i ++)
    {
        double Min = INF;
        int v;
        for(j = 1; j <= n; j ++)
        {
            if(flag[j] == 0 && low[j] < Min)
            {
                Min = low[j];
                v = j;
            }
        }
        sum += Min;
        vis[pre[v]][v] = vis[v][pre[v]] = 1;
        build(v, pre[v]);
        build(pre[v], v);
        flag[v] = 1;
        for(j = 1; j <= n; j ++)
        {
            if(flag[j] == 0 && low[j] > dis[v][j])
            {
                low[j] = dis[v][j];
                pre[j] = v;
            }
        }
    }
}
db dfs(int cur,int u,int fa) {
	db ans=INF;
	for(int i=head[u];~i;i=e[i].next) {
		if(e[i].to==fa) continue;
		db tmp=dfs(cur,e[i].to,u);
		ans=min(ans,tmp);
		dp[u][e[i].to]=dp[e[i].to][u]=min(tmp,dp[u][e[i].to]);
	}
	if(cur!=fa) 
		ans=min(ans,dis[cur][u]);
	return ans; 
}
db Dis(ii i,ii j) {
	return sqrt(1.0*(i.first-j.first)*(i.first-j.first)+1.0*(i.second-j.second)*(i.second-j.second));
}
void solve() {
	init();
	s_2(n,k);
	FOR(1,n,i) {
		int u,v;
		s_2(u,v);
		Q[i]={u,v};
	}
	FOR(1,n,i) {
		FOR(1,i,j) {
			dp[i][j]=dp[j][i]=INF;
			if(i==j) dis[i][j]=0;
			else dis[i][j]=dis[j][i]=Dis(Q[i],Q[j]);
		}
	}
	prim();
	db ans=sum;
	for(int i=0;i<n;i++) 
		dfs(i,i,-1);
	for(int i=2;i<=n;i++) 
		for(int j=2;j<i;j++) 
			if(vis[i][j]) ans=max(ans,sum-dis[i][j]+dp[i][j]);
	printf("%.2lf\n",ans*k);
}

int main() {
    //freopen( "1.in" , "r" , stdin );
    //freopen( "1.out" , "w" , stdout );
    int t=1;
    //init();
    s_1(t);
    for(int cas=1;cas<=t;cas++) {
        //printf("Case #%d: ",cas);
        solve();
    }
}

hdu 4126


#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<cmath>
#include<vector>
#define inf 0x3f3f3f3f
#define Inf 0x3FFFFFFFFFFFFFFFLL
#define eps 1e-9
#define pi acos(-1.0)
using namespace std;
typedef long long ll;
const int maxn=3000+10;
struct Edge
{
    int v;
    int next;
};
Edge edges[maxn<<1];
int head[maxn],nEdge;
int way[maxn][maxn],dis[maxn],pa[maxn],dp[maxn][maxn];
bool vis[maxn];
int n,m;
void clearAll()
{
    memset(vis,0,sizeof(vis));
    memset(head,0xff,sizeof(head));
    for(int i=0;i<n;++i)
       for(int j=0;j<n;++j)
         dp[i][j]=way[i][j]=inf;
    nEdge=-1;
}
void AddEdges(int u,int v)
{
    nEdge++;
    edges[nEdge].v=v;
    edges[nEdge].next=head[u];
    head[u]=nEdge;
}
ll prim()
{
    for(int i=0;i<n;++i) {dis[i]=way[0][i];pa[i]=0;}
    dis[0]=0;vis[0]=true;pa[0]=-1;
    ll res=0;
    int minnum,pos;
    for(int i=1;i<n;++i)
    {
        minnum=inf;
        for(int j=0;j<n;++j)
        {
            if(!vis[j]&&dis[j]<minnum)
            {
                minnum=dis[j];
                pos=j;
            }
        }
        res+=minnum;
        vis[pos]=true;
        if(pa[pos]!=-1)
        {
            AddEdges(pos,pa[pos]);
            AddEdges(pa[pos],pos);
        }
        for(int k=0;k<n;++k)
        {
            if(!vis[k]&&way[pos][k]<dis[k])
            {
                dis[k]=way[pos][k];
                pa[k]=pos;
            }
        }
    }
    return res;
}
int dfs(int u,int fa,int p)
{
    int ans=inf;
    for(int k=head[u];k!=-1;k=edges[k].next)
    {
        int v=edges[k].v;
        if(v==fa) continue;
        int tmp=dfs(v,u,p);
        ans=min(ans,tmp);
        dp[u][v]=dp[v][u]=min(dp[u][v],tmp);
    }
    if(fa!=p)
       ans=min(ans,way[u][p]);
    return ans;
}
int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    int a,b,c;
    while(~scanf("%d%d",&n,&m))
    {
        if(n==0&&m==0) break;
        clearAll();
        for(int i=0;i<m;++i)
        {
            scanf("%d%d%d",&a,&b,&c);
            way[a][b]=way[b][a]=c;
        }
        double sum=0;
        ll val=prim();
        for(int i=0;i<n;++i)
           dfs(i,-1,i);
        int q;
        scanf("%d",&q);
        for(int i=0;i<q;++i)
        {
            scanf("%d%d%d",&a,&b,&c);
            if(pa[a]!=b&&pa[b]!=a)
                sum+=val;
            else
                sum+=min(dp[a][b],c)+val-way[a][b];
        }
        printf("%.4lf\n",sum/q);
    }
    return 0;
}

 

 

hdu 4081

 


#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<map>
#include<queue>
#include<stack>
#include<cmath>
#include<vector>
#define inf 0x3f3f3f3f
#define Inf 0x3FFFFFFFFFFFFFFFLL
#define eps 1e-9
#define pi acos(-1.0)
using namespace std;
typedef long long ll;
const int maxn=1000+10;
const double INF=1e10;
struct Edge
{
    int u,v,next;
};
struct Point
{
    int x,y;
}points[maxn];
Edge edges[maxn<<1];
int head[maxn],nEdge;
void AddEdge(int u,int v)
{
    nEdge++;
    edges[nEdge].u=u;
    edges[nEdge].v=v;
    edges[nEdge].next=head[u];
    head[u]=nEdge;
}
double Len(Point a,Point b)
{
    return sqrt((double)(a.x-b.x)*(a.x-b.x)+(double)(a.y-b.y)*(a.y-b.y));
}
int n,val[maxn],pa[maxn],dp[maxn][maxn];
double ways[maxn][maxn],d[maxn],ans,prval;
bool vis[maxn];
void prime()
{
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n;++i) d[i]=ways[1][i],pa[i]=1;
    vis[1]=true;pa[1]=-1;prval=0;
    double minval;
    int pos;
    for(int i=1;i<n;++i)
    {
        minval=INF;
        for(int j=1;j<=n;++j)
        {
            if(!vis[j]&&d[j]<minval)
            {
                minval=d[j];
                pos=j;
            }
        }
        prval+=minval;
        vis[pos]=true;
        if(pa[pos]!=-1)
        {
            AddEdge(pos,pa[pos]);
            AddEdge(pa[pos],pos);
        }
        for(int k=1;k<=n;++k)
        {
            if(!vis[k]&&d[k]>ways[pos][k])
            {
                d[k]=ways[pos][k];
                pa[k]=pos;
            }
        }
    }
}
int dfs(int u,int fa,int p)
{
    int res=0;
    for(int k=head[u];k!=-1;k=edges[k].next)
    {
        int v=edges[k].v;
        if(v==fa) continue;
        int tmp=dfs(v,u,p);
        res=max(res,tmp);
        dp[u][v]=dp[v][u]=max(dp[u][v],tmp);
    }
    if(u!=p)
      res=max(res,val[u]+val[p]);
    return res;
}
int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for(int i=1;i<=n;++i)
           scanf("%d%d%d",&points[i].x,&points[i].y,&val[i]);
        for(int i=1;i<=n;++i)
          for(int j=i;j<=n;++j)
             ways[i][j]=ways[j][i]=Len(points[i],points[j]);
        memset(head,0xff,sizeof(head));
        nEdge=-1;
        prime();
        ans=0;
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=n;++i)
          dfs(i,-1,i);
        int u,v;
        for(int i=0;i<=nEdge;i+=2)
        {
            u=edges[i].u;v=edges[i].v;
            ans=max(ans,(dp[u][v])/(prval-ways[u][v]));
        }
        printf("%.2lf\n",ans);
    }
    return 0;
}

 

树形dp+MST-hdu-4126-Genghis Khan the Conqueror
cc_again的专栏
09-26 3005
题目链接： http://acm.hdu.edu.cn/showproblem.php?pid=4126 题目意思： 给一图，n个点，m条边，每条边有个花费，给出q条可疑的边，每条边有新的花费，每条可疑的边出现的概率相同，求不能经过原来可疑边（可以经过可疑边新的花费构建的边），注意每次只出现一条可疑的边，n个点相互连通的最小花费的期望。 解题思路： 树形dp+MST。 先用krus
无向图之最小生成树—Prim算法和Kruskal算法图文详解HDU1863
ChenTepiC
07-17 8039
学习算法的最好方式，我认为是应从思考一些有趣的题目开始。学习一个算法之前要知道这个算法的价值是什么。 附题：HDU 1863 最小生成树模板题  题目大意：询问你在各个村庄之间修公路，最少的花费是多少。 我们可以把“村庄&quot;抽象成一个一个点，把”修公路的费用&quot;抽象成连接两点的边值(权重)。 我们要求解决的是求出 把这些点(村庄)都连起来(修公路)时的所构成的树的权重总和最少(最少费用)是多少...
hdu 4126（最小生成树+dp）
LHYL
04-04 815
hdu 4126（最小生成树+dp）
hdu 4126
chm517的专栏
08-09 496
/*假设两个各自连通的部分分别为树A，树B 1. 用dp[i][j]表示树A中的点i 到 树B（j点所在的树）的最近距离， 这个过程可以在一边dfs就可以出来，对于每个 i 的dfs 复杂度是O(n) ， 外加一个n的循环求出每个点，这里的总复杂度为 O(n^2)。 2. 通过求出来的dp[i][j] 再用一个dfs 求出 树B 到 树A的最近距离， （方法：枚举树A中的所有点 到 树B的最近距
HDU 4126 Genghis Khan the Conqueror
Crossing over
04-18 401
传送门这个题借鉴了别人思想自己写的，题目大意是，给定图，保证每两点之间最多有一条直接相连的边，先给出原始图，然后Q次更新，每次增加某条边的权值，每次更新独立，求出本次的mst值，最后求平均。 所以问题就是根据每次更新以及原始mst求最新mst。两种情况， - 更新边不是原始mst上的。所以还是原始mst的值。 - 更新边是原始mst上的。因为更新一定是增加，所以这时这条边可能有一条原始ms
HDU - 4126 Genghis Khan the Conqueror(树形DP ＋ 最小生成树)
静静地码
08-21 999
题目大意：有N个点，M条路，现在给出K条路，这K条路是在M条路中将权值扩大的路。每给出一条，就要求求出最小生成树的权值 现在问每条路的最小生成树的权值和/K的最小值是多少解题思路：先得到最小生成树，然后判断路是不是最小生成树的树边，如果不是，就不影响了 如果是的话，就要判断一下是不是要去掉该边，再添加新的边。 如果去掉该边的话，就相当于把最小生成树划分成了两个块，所以现在需要的是一条最小边来连
HDU-2000-2099.rar_hdu
09-19
4. **图论**：包括深度优先搜索（DFS）、广度优先搜索（BFS）、最短路径算法（Dijkstra、Floyd-Warshall）、最小生成树（Prim、Kruskal）等。2101-2150号题目可能会涉及图的建立和分析，如网络流问题、旅行商问题等...
HDU-2000-2099.zip_hdu2000
09-23
10. **图论问题**：包括最小生成树（Prim算法和Kruskal算法）、最短路径（Dijkstra算法和Bellman-Ford算法）、网络流（Ford-Fulkerson算法和Edmonds-Karp算法）等。 通过深入学习和实践这些解题报告，不仅可以提升...
并查集应用：导引问题与最小生成树
&quot;导引问题-（HDUACM2010版_06）并查集（最小生成树）&quot; 在ACM程序设计中，我们经常会遇到一些组合优化问题，比如这个&ldquo;导引问题&rdquo;。这个问题设定在一个城市里，有n个人，而m条信息表明了这n个人之间的关系，即哪些人...
并查集详解：ACM竞赛中的最小生成树问题
&quot;题目分析-（HDUACM2010版_06）并查集（最小生成树）&quot; 这篇资源主要介绍了并查集这一数据结构及其在求解某些问题时的应用，特别是在构建最小生成树问题中的角色。并查集是一种用于管理不相交集合的数据结构，它提供...
HDU 4126 树形DP + prim
Since_natural_ran
08-07 376
树形DP + prim题意：给出一个连通的双向图，每一条边都有权值，现在有q次询问，每次都会更改一条边的cost，问q询问更改之后的平均最小生成树是多少。 注意更改的变的cost比原来大。 所有询问互不干扰 思路：直接的做法是每次更改之后求出最小生成树，然后相加所有询问情况输出平均值就行，但是q的范围比较大而prim的算法复杂度为n2n^2 ，所以会超时。考虑一下当更改了一条边会发生什么。 改的边
HDU 4756:Install Air Conditioning (最小生成树最佳替换边，最小生成树+树形dp)
温姑娘的博客
10-22 553
题目翻译： 由于给每个寝室都装了空调，所以要从电站（编号为1）往那些寝室送电。 所以要铺设线路，线路每米的花费为K。给出N个点，的坐标，第一个点 总代表电站的位置，剩余N-1个点是寝室的位置，欲想让费用最小，我们 肯定是求该图的最小生成树，但是由于构成最小生成树的边可能出故障， （与1相连的边不会出故障，因为1是电站，是唯一供电的地方，） 则该图就被分为S，T两个集合，追条删除构成最小
hdu4126(最小生成树最佳替换边)
stay_accept的专栏
06-26 1205
链接：点击打开链接 题意：给出一个无向图，有q次询问，每次更改一条边的距离，求出，每次更改后的最小生成树的平均值 代码：#include #include #include #include #include using namespace std; const int INF=0x3f3f3f3f; int son[5005],dfs_sort[5005],dfs_num[5005
HDU4126 Genghis Khan the Conqueror——最小生成树+树形DP（⭐）
lllllan
09-05 191
点这里 题意： 给定一个带权无向图G，n个点m条边，每条边都有一个权值w。题目保证两个点之间最多只有一条边。接下来有Q次边权的改变，且改变后的权值之后一定比原来的更大。求每次改变边权之后的所有最小生成树的平均值（边权的改变前后不影响。 题解： 构造最小生成树： 在没有任何边权改变之前，求出最原始的最小生成树，记录这棵树的权值和ans。 边权替换： 再次强调，每次边权的改变，是独立操作、前后互补影响的。明确之后再对改变的边权进行分类讨论： 边在树上： 这次改变的边在最原始的最小生成树上，并...
HDU4126 - 最小生成树 + DP
aixia9842的博客
07-20 235
HDU4126 - 最小生成树 + DP 题目链接 题目大意 给你一个图，有q次询问，每次询问如果替换一条边后最小生成树的大小是多少，求q次询问的平均值。（要替换的边的权一定不小于原来边权，替换只在当前次询问有效） 数据范围 多组输入T&lt;=20，1≤N≤3000,0≤M≤N∗N1≤N≤3000,0≤M≤N∗N,边...
hdu4126.Genghis Khan the Conqueror
nothi的专栏
08-20 2540
http://acm.hdu.edu.cn/showproblem.php?pid=4126        题目的大意是给你一张连通图，共有Q次更改，每次在原图的基础上，增加一条边的权值，求每次更改后最小生成树的权的总和sum,并输出sum/Q；        思路:对原图做一次pim(),求出最小生树，如果修改的权值不是最小生成树的边，那边最小生成树不变。否则，假设修改的边是(a,b)并把(
HDU4126(最小生成树+离线处理)
lifeforge的博客
11-19 197
好题 最小生成树+离线处理 对于生成树上的u-&gt;v这条边，我们考虑删去u-&gt;v后，u和v会构成两棵树,我们从v开始遍历v这棵树，每次更新记录dp[u][v]即可 离线处理的复杂度为O(n2)O(n^2)O(n2) 代码部分挺乱的，有时间再整理 #include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;cstring&gt; #include &lt;algorithm&gt; #include &lt;cmath&gt; #in
hdu4126(MST + 树形dp
天使也掉毛
03-08 1065
题意:       这个题目和hdu4756差不多,是给你一个图,然后是q次改变边的权值,权值只增不减,最后问你每次改变之后的最小树的平均值是多少. 思路:       先跑一边最小树(建议用普利姆,别用克鲁斯卡尔,虽然网上有用k过的,但我感觉理论上会超时 n*n*nlog(n)/2),然后树形dp跑出任意两个集合之间的最有替代边.(n^2),然后当每次输入一条要该边的边的时候,
hdu 4756 Install Air Conditioning(MST+全边次小树，4级)
nealgavin的专栏
09-22 1381
Install Air Conditioning Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65535/65535 K (Java/Others) Total Submission(s): 174    Accepted Submission(s): 23 Problem Description   
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值