培训补坑(day5:最小生成树+负环判断+差分约束)

补坑补坑((╯‵□′)╯︵┻━┻)

内容真的多。。。

一个一个来吧。

首先是最小生成树。

先讲一下生成树的定义

生成树就是在一张图上选取一些边,使得整个图上所有的点都连通。

那么我们要求的最小生成树有两种算法可以求:1、prim算法,2、kruskal算法

我们先讲讲prim算法

prim算法有点像最短路中的dijstra,操作都几乎一样,原理就是从所有在队列中的点出发,找到最小的一条边,并把它连起来,这样子能够保证局部最优性。

在此我不讲这种算法,不过有兴趣的人可以去学一学。

我重点推出的是kruskal算法:原因就是:又短,又好写,而且一点都不难理解。

首先我们先把所有的边都排个序,然后我们从小到大枚举所有的边,如果一条边两端的点不在同一个集合内,那么我们就链接这一条边,并且合并集合(合并集合的操作可以用并查集快速维护)

下面附上代码

#include<cstdio>
#include<algorithm>
#define MN 5005
#define M 200005
using namespace std;
int n,m,cnt=0,ans=0;
int f[MN];
struct edge{
    int u,v,w;
}g[M];
bool cmp(edge a,edge b){return a.w<b.w;}
int getf(int x){return !f[x]?x:f[x]=getf(f[x]);}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)scanf("%d%d%d",&g[i].u,&g[i].v,&g[i].w);
    sort(g+1,g+m+1,cmp);
    for(int i=1;i<=m&&cnt<n-1;i++){
        int x=getf(g[i].u),y=getf(g[i].v);
        if(x!=y){
            cnt++;
            ans+=g[i].w;
            f[x]=y;
        }
    }
    if(cnt==n-1)printf("%d\n",ans);else puts("orz");
}

如果对于这两种算法不懂的同学们可以去这篇博客上看一看它的图解,我就不献丑啦QAQ(其实是内容太多,比较懒QAQ)

——————————————————我是分割线———————————————————

下面讲一讲负环判断:

我们在上次讲过一次最短路,而我在那一次的讲解中提到过,dij算法是不能在有负环的图中跑的。

这也就意味着,spfa可以。

对于每次spfa中,如果我们不使用循环队列,那么我们的队列元素开的大小就是n*n

这是因为在spfa中,一个点最多入队n次。可是如果我们想,spfa中出现负环会怎么样呢?

显然,环内的点会重复入队,然后T掉。

但这样也说明,如果一个点入队次数超过n次,那么一定有负环出现。

这也就是我们判断负环的方法。

在spfa中我们开一个cnt数组记录每个点入队的次数,如果次数超过n次,那么就存在负环。

由于太过简单,代码我就不贴了QAQ

——————————————————我是分割线———————————————————

最后是差分约束。

差分约束的意思就是说,在一道题中有很多的变量,变量之间满足很多的不等式,然后要我们求解的一系列问题。

我们先来看一看例题。

——————————————————我是分割线———————————————————

题目:

  当排队等候喂食时,奶牛喜欢和它们的朋友站得靠近些。FJ有N(2<=N<=1000)头奶牛,编号从1到N,沿一条直线站着等候喂食。奶牛排在队伍中的顺序和它们的编号是相同的。因为奶牛相当苗条,所以可能有两头或者更多奶牛站在同一位置上。即使说,如果我们想象奶牛是站在一条数轴上的话,允许有两头或更多奶牛拥有相同的横坐标。 
    一些奶牛相互间存有好感,它们希望两者之间的距离不超过一个给定的数L。另一方面,一些奶牛相互间非常反感,它们希望两者间的距离不小于一个给定的数D。给出ML条关于两头奶牛间有好感的描述,再给出MD条关于两头奶牛间存有反感的描述。(1<=ML,MD<=10000,1<=L,D<=1000000) 
    你的工作是:如果不存在满足要求的方案,输出-1;如果1号奶牛和N号奶牛间的距离可以任意大,输出-2;否则,计算出在满足所有要求的情况下,1号奶牛和N号奶牛间可能的最大距离。

我们先来看一看一个等式,比如题目中要求的第一个等式:d[j]-d[i]<=L,这个等式有没有感觉有点熟悉?细心的人就会发现当d[j]-d[i]>L的时候就要更新答案,这不就是最短路吗!!

是的,这就是最短路,于是我们就将一个数论问题变成了一个图论问题。

所以我们只需要把所有不等式转换为d[i]-d[j]<=L的不等式,然后我们从j到i连一条L的边

然后我们对着这个图直接跑最短路就好了(是不是很棒!)

那么我们又要怎么判断-1呢?这就是我们上面讲的负环判断的应用了。因为如果出现负环,很显然就无法满足条件,那么就是无解情况了。

下面讲两个建图的容易错误的地方;

一个是有时候题目会要求不能有2个人同时站在同一位置上。所以我们有时候需要满足d[i+1]-d[i]>=1不等式

还有就是如果要求A和B相同,那么我们要在AB之间连上双向边。

那么今天的总结就到这里啦。

附上这道例题的代码。

#include<cstdio>
#include<cstring>
#define MN 30005
#define inf 0x3f3f3f3f
#define M 1005
using namespace std;
inline int read()
{
    int x=0;char ch=getchar();
    while(ch<‘0‘||ch>‘9‘){ch=getchar();}
    while(ch>=‘0‘&&ch<=‘9‘){x=(x<<3)+(x<<1)+ch-‘0‘;ch=getchar();}
    return x;
}
int head[M],cnt[M],dis[M],que[M<<1];
int n,ml,md,num,t;
bool visit[M];
struct edge{
    int to,next,val;
}g[MN];
void ins(int u,int v,int we){g[++num].next=head[u];head[u]=num;g[num].to=v;g[num].val=we;}
void insw(int u,int v,int we){ins(u,v,we);ins(v,u,we);}
bool spfa(){
    for(int i=1;i<=n;i++)dis[i]=inf;
    memset(visit,0,sizeof(visit));
    int h=1,tail=1;que[h]=1;dis[1]=0;
    while(h<=tail){
        int tmp=que[h++];
        for(int i=head[tmp];i;i=g[i].next)
            if(dis[g[i].to]>dis[tmp]+g[i].val){
            dis[g[i].to]=dis[tmp]+g[i].val;cnt[g[i].to]++;
                if(!visit[g[i].to]){
                    visit[g[i].to]=1;
                    if(cnt[g[i].to]>n)return true;
                    if(dis[g[i].to]<dis[que[h]])que[--h]=g[i].to;
                    else que[++tail]=g[i].to;
                }
            }
        visit[tmp]=0;
    }
    return false;
}
int main(){
    scanf("%d%d%d",&n,&ml,&md);
    int s,t,value;
    for(int i=2;i<=n;i++)ins(i,i-1,0);
    for(int i=1;i<=ml;i++)scanf("%d%d%d",&s,&t,&value),ins(s,t,value);
    for(int i=1;i<=md;i++)scanf("%d%d%d",&s,&t,&value),ins(t,s,-value);
    if(spfa())printf("-1\n");
    else if(dis[n]==inf)printf("-2\n");
    else printf("%d\n",dis[n]);
}
时间: 2024-11-03 21:11:51

培训补坑(day5:最小生成树+负环判断+差分约束)的相关文章

Poj 3259 Wormholes 负环判断 SPFA &amp; BellmanFord

#include <cstdio> #include <cstring> #include <cmath> #include <algorithm> #include <climits> #include <string> #include <iostream> #include <map> #include <cstdlib> #include <list> #include <

培训补坑(day7:线段树的区间修改与运用)(day6是测试,测试题解以后补坑QAQ)

补坑咯~ 今天围绕的是一个神奇的数据结构:线段树.(感觉叫做区间树也挺科学的.) 线段树,顾名思义就是用来查找一段区间内的最大值,最小值,区间和等等元素. 那么这个线段树有什么优势呢? 比如我们要多次查询1-n中的最大值,那么我们如果使用暴力来查找,那么我们每次查找的复杂度就是O(n) 但是如果我们把一个个区间变成树上的一个个点,并且我们严格保证树的深度,那么我们每次查找的复杂度就是O(logn) 这样就能让查询变得更快. 我们先简单讲一下线段树的存储(图中的标号就是线段树数组标号) 这就是线段

培训补坑(day3:网络流&amp;最小割)

继续补坑.. 第三天主要是网络流 首先我们先了解一下网络流的最基本的算法:dinic 这个算法的主要做法就是这样的: 在建好的网络流的图上从源点开始向汇点跑一遍BFS,然后如果一条边的流量不为0,那么就往下标号, 每一个点的level都是上一个点的level+1 然后在跑一遍DFS,如果发现边的两个点的level差值为1(终点比起点的level大),那么就走这条边. 那么我们首先要了解一下如何建边 网络流的最基本概念就是:可以反悔 就是说假如说我们有更好的方案,那么我们可以把原来流掉的流量再流回

培训补坑(day4:网络流建模与二分图匹配)

补坑时间到QAQ 好吧今天讲的是网络流建模与二分图匹配... day3的网络流建模好像说的差不多了.(囧) 那就接着补点吧.. 既然昨天讲了建图思想,那今天就讲讲网络流最重要的技巧:拆点. 拆点,顾名思义,就是把一个状态拆成数个点以满足题目要求. 今天主要围绕一个例题来讲:修车.(虽然是丧题,但是却是网络流算法思想实现的典例) ------------------我是分割线------------------ 题目: 同一时刻有位车主带着他们的爱车来到了汽车维修中心.维修中心共有M位技术人员,不

Hdu 4594 Difference(奇圈判断+差分约束)

题目地址:http://acm.hdu.edu.cn/showproblem.php?pid=4598 思路:由题意可知两相连点ai符号一定相反,所以若存在奇圈则一定无解.染色,colour[i]==1表示为正,colour[i]==2表示为负.由于(b)条件为充要条件,所以对于图中的点| a[i]-a[j] | >= T,对于非图中点| a[i]-a[j] | < T,即| a[i]-a[j] | <= T-1 .所以图中点,若colour[i]==1,a[i]-a[j] >=

一种科学的判断负环的方法

判断负环的方法 ------------ 这里有个叫分界线的家伙突然想说,本章主体思路都是在 SPFA 上的o ------------ 感觉分为两种大方向,\(BFS\) 和 \(DFS\) 快速写一下 \(BFS\) 的思路 由 \(SPFA\) 的算法可以发现,如果要更新一个点的 \(dis\) ,那么一定有一个点先被更新了以后,然后通过这个新更新的点来更新这个点,那么在没有负环的情况下,一个点能被更新的最多次数为 \(n\) 次,也就是说,如果一个点进队的次数大于 \(n\) 了,嘿嘿嘿

HDU 1217 Arbitrage(Bellman-Ford判断负环+Floyd)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1217 题目大意:问你是否可以通过转换货币从中获利 如下面这组样例: USDollar 0.5 BritishPound BritishPound 10.0 FrenchFranc FrenchFranc 0.21 USDollar 可以通过US->Br->French->US这样转换,把1美元变成1*0.5*10*0.21=1.05美元赚取%5的利润. 解题思路:其实就相当于bellman-

vijos1053 用spfa判断是否存在负环

MARK 用spfa判断是否存在负环 判断是否存在负环的方法有很多, 其中用spfa判断的方法是:如果存在一个点入栈两次,那么就存在负环. 细节想想确实是这样,按理来说是不存在入栈两次的如果边权值为正的话 这个算法是O(N*M) 还有一种方法是直接用bellman-ford,虽说spfa也就是bellman-ford+FIFO队列 而且bellman-ford还可以计算负环的值 顺手附上代码好了: for(int i=0;i<n;i++) d[i]=INF;//初始化 d[0]=0; for(i

poj 3259 Wormholes(bellman-ford判断负环)

题目链接:http://poj.org/problem?id=3259 题目就是问你能否回到原点而且时间还倒回去了.题目中有些路中有单向的虫洞能让时间回到过去 所以只要将虫洞这条边的权值赋为负然后再判断有没有负环就行了. #include <iostream> #include <cstring> using namespace std; const int inf = 10001; int f , n , m , w ,dis[1001] , counts; struct TnT