[SCOI2011]糖果(差分约束(爆long long爆T特判)+spfa的判负环的dfs优化(玄学？？)+tarjan&缩点&topsort上的dp与判环 )

最新推荐文章于 2021-05-13 16:50:57 发布
最新推荐文章于 2021-05-13 16:50:57 发布
阅读量322 收藏 2
点赞数 1
文章标签： The differential constraints DFS optimization of spfa Tarjan condensation point&tops
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouzi2018/article/details/85594886
版权

题意：传送门

题解：这道题一眼看上去就是差分约束板题，但是有两个大坑，先说下如何建图，对于

op==1 a==b a-b>=0 b-a>=0

op==2 a<b a<=b-1 a-b<=-1 b-a>=1

op==3 a>=b a-b>=0

op==4 a>b a-1>=b a-b>=1

op==5 a<=b a-b<=0 b-a>=0

还有每个孩子的糖果都是正数，那么所有的的a-0>=1

可以看出，我是全部转化成>=进行来做，然后就是跑最长路，但是这样就太弱了，发现第一发wa，后经分析，ans爆long long，之后有一个点老是T，看了许多题解，第一种是最关键的地方，就是在第二个和第四个操作时如果一旦有输入的两个点是相同的，那么岂不是有自环，并且环上有权值，那么岂不是直接输出不可以就行，此时就可以A了

附上代码：



#include<bits/stdc++.h>

using namespace std;

const int maxm=1e6+50;
const int maxn=1e5+50;

struct edge{
    int v,w,next;
};
edge edges[maxm<<2];
int head[maxn],tot;

void init()
{
    memset(head,-1,sizeof(head));
    tot=0;
}

void add_edges(int u,int v,int w)
{
    edges[tot].v=v;
    edges[tot].w=w;
    edges[tot].next=head[u];
    head[u]=tot++;
}

int n,k;
bool vis[maxn];
int cnt[maxn];
int dist[maxn];

bool spfa()
{
    queue<int>q;
    for(int i=0;i<=n;i++){
        q.push(i);
        vis[i]=false;dist[i]=0;cnt[i]=1;
    }
    while(!q.empty()){
        int u=q.front();
        q.pop();
        vis[u]=0;
        for(int i=head[u];~i;i=edges[i].next){
            int v=edges[i].v;
            if(dist[v]<dist[u]+edges[i].w){
                dist[v]=dist[u]+edges[i].w;
                if(!vis[v]){
                    vis[v]=1;
                    q.push(v);
                    if(++cnt[v]>n+1){
                        return false;
                    }
                }
            }
        }
    }
    return true;
}

int a[maxn];

int main()
{
    init();
    scanf("%d%d",&n,&k);
    int op,a,b;
    for(int i=0;i<k;i++){
        scanf("%d%d%d",&op,&a,&b);
        a--;b--;
        if(op==1){
            add_edges(a,b,0);
            add_edges(b,a,0);
        }else if(op==2){
            add_edges(a,b,1);
        }else if(op==3){
            add_edges(b,a,0);
        }else if(op==4){
            add_edges(b,a,1);
        }else if(op==5){
            add_edges(a,b,0);
        }
        if(op%2==0&&a==b){
            printf("-1\n");
            return 0;
        }
    }
    for(int i=0;i<n;i++){
        add_edges(n,i,1);
    }
    if(spfa()){
        long long ans=0;
        for(int i=0;i<n;i++){
            ans+=dist[i]-dist[n];
        }
        printf("%lld\n",ans);
    }else{
        printf("%d\n",-1);
    }
    return 0;
}

还可以再进行优化，终于看了传说中的dfs优化的spfa，可以了解下这个传送门，可以参考下这篇，虽然感觉没讲到重点传送门，这篇文章说了如果不存在最短路的情况下，这样跑是没问题，但是现在要用dfs判断是否存在负环，那么就得重新写一种判断方法了，但是改成dfs后，竟然还有一个点T，然后看到网上有人说是因为最后加特判每个数是正数那个点时需要从后往前加，因为出题人出了一个十万条的链？？？什么意思，玄学么，然后仔细想了想自己为什么第一发就能过，因为自己入队时就是从前往后入的，这题？？？搞的不是很懂，还是先学一发dfs优化的spfa跑跑。

附上代码：



#include<bits/stdc++.h>

using namespace std;

const int maxm=1e6+50;
const int maxn=1e5+50;

struct edge{
    int v,w,next;
};
edge edges[maxm<<2];
int head[maxn],tot;

void init()
{
    memset(head,-1,sizeof(head));
    tot=0;
}

void add_edges(int u,int v,int w)
{
    edges[tot].v=v;
    edges[tot].w=w;
    edges[tot].next=head[u];
    head[u]=tot++;
}

int n,k;
bool vis[maxn];
int cnt[maxn];
int dist[maxn];

bool spfa()
{
    queue<int>q;
    for(int i=0;i<=n;i++){
        q.push(i);
        vis[i]=false;dist[i]=0;cnt[i]=1;
    }
    while(!q.empty()){
        int u=q.front();
        q.pop();
        vis[u]=0;
        for(int i=head[u];~i;i=edges[i].next){
            int v=edges[i].v;
            if(dist[v]<dist[u]+edges[i].w){
                dist[v]=dist[u]+edges[i].w;
                if(!vis[v]){
                    vis[v]=1;
                    q.push(v);
                    if(++cnt[v]>n+1){
                        return false;
                    }
                }
            }
        }
    }
    return true;
}

int book[maxn];

bool dfs(int p)
{
    book[p]=true;
    for(int i=head[p];~i;i=edges[i].next){
        edge &e=edges[i];
        if(dist[e.v]<dist[p]+e.w){
            dist[e.v]=dist[p]+e.w;
            if(book[e.v]||!dfs(e.v)){
                return false;
            }
        }
    }
    book[p]=false;
    return true;
}

int a[maxn];

int main()
{
    init();
    scanf("%d%d",&n,&k);
    int op,a,b;
    for(int i=0;i<k;i++){
        scanf("%d%d%d",&op,&a,&b);
        a--;b--;
        if(op==1){
            add_edges(a,b,0);
            add_edges(b,a,0);
        }else if(op==2){
            add_edges(a,b,1);
        }else if(op==3){
            add_edges(b,a,0);
        }else if(op==4){
            add_edges(b,a,1);
        }else if(op==5){
            add_edges(a,b,0);
        }
        if(op%2==0&&a==b){
            printf("-1\n");
            return 0;
        }
    }
    for(int i=n-1;i>=0;i--){
        add_edges(n,i,1);
    }
    dist[n]=0;
    if(dfs(n)){
        long long ans=0;
        for(int i=0;i<n;i++){
            ans+=dist[i];
        }
        printf("%lld\n",ans);
    }else{
        printf("%d\n",-1);
    }
    return 0;
}

最后还有一种是使用tarjan+缩点+dp做出来的，说下题解，首先只加上1、3、5三种情况的边，如果a<=b那么a向b连边，如果相等就两边都连。然后我们用Tarjan缩一遍环，然后可以构出一个DAG(有向无环图)。由于缩掉的都是1、3、5情况的边，那么他们构成的环就意味着环上的点必须相等。缩环之后重构图，加上2、4情况的边，这个时候要特判：如果此时有一条2、4的边构成自环（意味着它在原图中连接了两个必须相等的点），所以直接输出-1结束。然后我们给图来一遍拓扑排序，如果此时出现环（拓扑排序有些点没有访问到），必然意味着后面新加的2、4情况的边构成了环（1、3、5情况的边已经没有环了），此时也要直接输出-1结束。最后按照拓扑序来一遍dp就可以得出结果。（统计结果记得用long long）

附上代码：

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
using namespace std;
const int maxn=100010;
struct relationship{
    int x,a,b;
}r[maxn];
struct edge{
    int to,next;
    bool same;//记录该边是否允许两边相等  
}e[maxn<<1],e2[maxn];
int n,m,num,num2,cnt,head[maxn],head2[maxn],ltk[maxn],dfn[maxn],low[maxn];
int sta[maxn],top,size[maxn],que[maxn],du[maxn],h,tail,candy[maxn];
bool vis[maxn];
long long ans=0;
void add(int u,int v,bool k){
    e[++num].to=v;e[num].same=k;e[num].next=head[u];head[u]=num;
}
void add2(int u,int v,bool k){
    du[v]++;
    e2[++num2].to=v;e2[num2].same=k;e2[num2].next=head2[u];head2[u]=num2;
}
void dfs(int x){
    dfn[x]=low[x]=++cnt;sta[++top]=x;
    for(int i=head[x];i;i=e[i].next){
        if(!dfn[e[i].to]){
            dfs(e[i].to);
            low[x]=min(low[x],low[e[i].to]);
        }
        else if(!ltk[e[i].to]){
            low[x]=min(low[x],dfn[e[i].to]);
        }
    }
    if(dfn[x]==low[x]){
        ltk[0]++;
        while(top){
            ltk[sta[top]]=ltk[0];
            size[ltk[0]]++;
            if(sta[top--]==x)break;
        }
    }
}
void Rebuild(){
    for(int i=1;i<=n;i++){
        for(int j=head[i];j;j=e[j].next){
            if(ltk[i]!=ltk[e[j].to]){
                add2(ltk[i],ltk[e[j].to],true);
            }
        }
    }
    for(int i=1;i<=m;i++){
        if(r[i].x==2){
            if(ltk[r[i].a]==ltk[r[i].b]){
                printf("-1\n");
                exit(0);
            }
            else{
                add2(ltk[r[i].a],ltk[r[i].b],false);
            }
        }
        else if(r[i].x==4){
            if(ltk[r[i].a]==ltk[r[i].b]){
                printf("-1\n");
                exit(0);
            }
            else{
                add2(ltk[r[i].b],ltk[r[i].a],false);
            }
        }
    }
}
void Topsort(){
    for(int i=1;i<=ltk[0];i++){
        if(!du[i]){
            que[++tail]=i;
            vis[i]=true;
            candy[i]=1;       //candy[i]记录i节点每个孩子要多少糖
        }
    }
    while(h<tail){
        int x=que[++h];
        for(int i=head2[x];i;i=e2[i].next){
            if(!--du[e2[i].to]){
                que[++tail]=e2[i].to;
                vis[e2[i].to]=true;
            }
            if(!e2[i].same){
                candy[e2[i].to]=max(candy[e2[i].to],candy[x]+1);
            }
            else{
                candy[e2[i].to]=max(candy[e2[i].to],candy[x]);
            }//dp，如果有一条边不允许相等就要+1 
        }
    }
    for(int i=1;i<=ltk[0];i++){
        if(!vis[i]){
            printf("-1\n");
            exit(0);
        }
    }
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){
        scanf("%d%d%d",&r[i].x,&r[i].a,&r[i].b);
        if(r[i].x==1){
            add(r[i].a,r[i].b,true);
            add(r[i].b,r[i].a,true);
        }
        else if(r[i].x==3){
            add(r[i].b,r[i].a,true);
        }
        else if(r[i].x==5){
            add(r[i].a,r[i].b,true);
        }
    }
    for(int i=1;i<=n;i++){
        if(!dfn[i]){
            dfs(i);
        }
    }
    Rebuild();Topsort();
    for(int i=1;i<=ltk[0];i++){
        ans+=(candy[i]*size[i]);//记录答案，记得开long long
    }
    printf("%lld\n",ans);
    return 0;
}

 

肘子zhouzi
关注
【BZOJ 2330】 [SCOI2011]糖果【差分约束】
skysys的研究小屋
11-16 1615
题目跳转: http://www.lydsy.com/JudgeOnline/problem.php?id=2330 Description 幼儿园里有N个小朋友，lxhgww老师现在想要给这些小朋友们分配糖果，要求每个小朋友都要分到糖果。但是小朋友们也有嫉妒心，总是会提出一些要求，比如小明不希望小红分到的糖果比他的多，于是在分配糖果的时候，lxhgww需要满足小朋友们的K个要求。幼儿
[SCOI2011] 糖果
Bill_Yang_2016的博客
12-10 424
差分约束系统
「SCOI2011」糖果（spfa）
nearal的博客
03-09 287
幼儿园里有 n 个小朋友， lxhgww 老师现在想要给这些小朋友们分配糖果，要求每个小朋友都要分到糖果。 但是小朋友们也有嫉妒心，总是会提出一些要求，比如小明不希望小红分到的糖果比他的多，于是在分配糖果的时候， lxhgww 需要满足小朋友们的 k个要求。 幼儿园的糖果总是有限的， lxhgww 想知道他至少需要准备多少个糖果，才能使得每个小朋友都能够分到糖果，并且满足小朋友们所有的要求。 输入格式 输入的第一行是两个整数 n ，k 。 接下来 k 行，表示这些点需要满足的关系，每行 3 个数字，x
【SCOI 2011】糖果
weixin_44336566的博客
04-17 117
#include<iostream> #include<stdio> #include<algorithm> #include<cmath> using namespace std; const int N=100005; struct nmmp{ int u,v,next,w }d[N]; int first[N],k;/////////////...
[SCOI2011]糖果
Canopus
10-24 349
Description 幼儿园里有NN个小朋友，lxhgww老师现在想要给这些小朋友们分配糖果，要求每个小朋友都要分到糖果。但是小朋友们也有嫉妒心，总是会提出一些要求，比如小明不希望小红分到的糖果比他的多，于是在分配糖果的时候，lxhgww需要满足小朋友们的KK个要求。幼儿园的糖果总是有限的，lxhgww想知道他至少需要准备多少个糖果，才能使得每个小朋友都能够分到糖果，并且满足小朋友们所有的要求。
luogu P3275 [SCOI2011]糖果
zsyz_ZZY的博客
03-27 462
背景： 数学竞赛二等，基本卡线（按照WJWJWJ的说法，过程怒扣20+pts20+pts20+pts），惨… （之前的看错题是假的） 题目传送门： https://www.luogu.org/problemnew/show/P3275 题意： 一些人，他们的权值满足一些关系，求权值和的最小值。 思路： 查分约束裸题。 但是有些坑，不知道为什么正常建边用spfaspfaspfa会超时（9...
SCOI2011 糖果（差分约束）
Michael_GLF的博客
10-11 436
【题目描述】 幼儿园里有N个小朋友，lxhgww老师现在想要给这些小朋友们分配糖果，要求每个小朋友都要分到糖果。但是小朋友们也有嫉妒心，总是会提出一些要求，比如小明不希望小红分到的糖果比他的多，于是在分配糖果的时候，lxhgww需要满足小朋友们的K个要求。幼儿园的糖果总是有限的，lxhgww想知道他至少需要准备多少个糖果，才能使得每个小朋友都能够分到糖果，并且满足小朋友们所有的要求。 【输入格...
P3275 [SCOI2011]糖果（差分约束板子）
纸箱xyr
03-20 401
题意：有n个人分发糖果，m项约束条件，问至少需要准备多少糖果。 输入的第一行是两个整数NN，KK。接下来KK行，表示这些点需要满足的关系，每行33个数字，XX，AA，BB。 如果X=1X=1， 表示第AA个小朋友分到的糖果必须和第BB个小朋友分到的糖果一样多； 如果X=2X=2， 表示第AA个小朋友分到的糖果必须少于第BB个小朋友分到的糖果； 如果X=3X=...
【SCOI2011】糖果(差分约束)
liaoxiyan123的博客
08-03 491
题目描述 省选入门题大门 幼儿园里有N个小朋友,lxhgww{\text{lxhgww}}lxhgww老师现在想要给这些小朋友们分配糖果,要求每个小朋友都要分到糖果.但是小朋友们也有嫉妒心,总是会提出一些要求,比如小明不希望小红分到的糖果比他的多,于是在分配糖果的时候,lxhgww{\text{lxhgww}}lxhgww需要满足小朋友们的 K个要求。幼儿园的糖果总是有限的,lxhgww{\text{lxhgww}}lxhgww想知道他至少需要准备多少个糖果，才能使得每个小朋友都能够分到糖果，并且满足小朋
SCOI2011——糖果（差分约束系统）
weixin_30785593的博客
10-30 205
描述 幼儿园里有N个小朋友，lxhgww老师现在想要给这些小朋友们分配糖果，要求每个小朋友都要分到糖果。但是小朋友们也有嫉妒心，总是会提出一些要求，比如小明不希望小红分到的糖果比他的多，于是在分配糖果的时候，lxhgww需要满足小朋友们的K个要求。幼儿园的糖果总是有限的，lxhgww想知道他至少需要准备多少个糖果，才能使得每个小朋友都能够分到糖果，...
洛谷P3275 [SCOI2011]糖果_差分约束_判负环
EM LGH
09-22 130
Code: #include&amp;lt;cstdio&amp;gt; #include&amp;lt;queue&amp;gt; #include&amp;lt;algorithm&amp;gt; using namespace std; const int N=300000+3; const int INF=-2333233; queue&amp;lt;int&amp;gt;Q; int d[N],inq[N],times[N]; int head[N]...
【洛谷P3275】糖果【差分约束】【负环】
stoorz
02-16 339
题目大意： 题目链接：https://www.luogu.org/problemnew/show/P3275 有nnn个小朋友和mmm个要求，其中要求的格式如下： 1&amp;nbsp;A&amp;nbsp;B1\ A\ B1&amp;nbsp;A&amp;nbsp;B， 表示第 AAA 个小朋友分到的糖果必须和第 BBB 个小朋友分到的糖果一样多； 2&amp;nbsp;A&amp;nbsp;B2\ A\ B2&amp;nbsp;A&amp;nbsp;B，...
[SCOI2011]糖果 差分约束+判环
恒持此志成永志
04-09 213
[SCOI2011]糖果 显然差分约束，根据条件建立所有边，注意相等建立双向边。 至于为什么跑最长路，我认为是只有式子 i - 0 >= 1才能建立0到 i (i从1到n)的边，这样才能把所有点连起来。 不过这里的题解没有建立0到 i 的所有边，因为从 0 开始直接spfa 判断 n 次 会TLE，就对每个点用dfs的spfa，这种处理对于负权环较快。ans开long long 。...
spfa判负环优化
wen_xp的专栏
03-05 686
题目意思就是是否存在ai,bj，使得l 首先，把cij除到两边:l' log(l') 把log(ai)和log(bj)看成两个点ai和bj，化成求最短路的形式：dis[ai]-dis[bj] 判断有无解（负环）的时候，如果用spfa，不能用入队次数大于N来判断，会超时。 有如下两种比较可靠的方法（一般情况下） 1：某个点入队次数大于sqrt(N)的时候 2
POJ3259——SPFA的DFS优化判断负环
qq_41508508的博客
07-13 736
题目描述：耳机楼里有很多教室，这些教室由双向走廊连接。另外，还存在一些单向的秘密通道，通过它们可以回到过去。现在有 N (1 ≤ N ≤ 500) 个教室，编号 1..N, M (1 ≤ M ≤ 2500) 条走廊，和 W (1 ≤ W≤ 200) 条秘密通道。DY在养猫之余，还是一个时间旅行爱好者。她希望从一间教室出发，经过一些走廊和秘密通道，回到她出发之前的某个时间。共有F (1 ≤ F ≤ ...
POJ 3169（差分约束系统+SPFA判断负环）
积少成多，水滴石穿
06-12 212
POJ 3169 （1）题意： 有n头奶牛，有ML对奶牛相互喜欢，它们之间的距离不得超过x， 有MD对奶牛相互讨厌，它们之间的距离不得小于x。 询问是否有一种方案将所有奶牛（从1到n）排队，允许距离相同的奶牛在同一个位置。 如果存在这种排队方案，输出这个方案的最长距离； 如果不存在这种排队方案，-2； 如果存在方案但是距离为INF，输出-1. （2）思路： A，B相互...
模板 - 判断负环（超时高效优化技巧）、01分数规划
繁凡さん的博客
07-22 681
模板 - 判断负环（超时高效优化技巧）、01分数规划
POJ - 3259 SPFA判断负环 队列优化 邻接表 超级源点 图论
从你的全世界路过
05-13 127
题目 链接 题解思路 当存在负环时，时间就能通过负环不断减去。这样就能回到截止之前。 判断思路和正环类似，代码和最短路类似，取小的一方，当一个点被松弛超过 N次时 ，存在负环 。 调了半天发现double存int变0了。 AC代码 #include <iostream> #include <cstdio> #include <vector> #include <cstring> #include <queue> using namespace s
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值