Codeforces Round #372 (Div. 2) D. Complete The Graph 好题+图论+思维+二分

最新推荐文章于 2019-10-03 21:03:42 发布
最新推荐文章于 2019-10-03 21:03:42 发布
阅读量417 收藏
点赞数 1
分类专栏： acm 文章标签： 图论 最短路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013944294/article/details/54233710
版权

将可改变的边长度先置为1，不断用dij跑最短路，若d[t]<L，增加可改变边的权值使该条最短路长度为L。直至跑完后d[t]==L结束。

注意原本的最短路已经小于L的情况，此时，最坏可能得跑m次dij，时间复杂度O（mmlogn），2168ms。

#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
#include <set>
#include <algorithm>
using namespace std;
#define fst first
#define snd second
typedef long long ll;
typedef unsigned int uii;
typedef pair<ll,int> pli;
typedef pair<int,int> pii;
const ll inf=1e15;
const int maxn=1005;
const int maxm=10005;
int n,m,s,t,u,v;
set<pii> st;
ll w,d[maxn],L;
pii fa[maxn];
struct ee {
    int u,v,id;
    bool f;
    ll w;
    ee(){}
    ee(int u,int v,int id,bool f,ll w):u(u),v(v),id(id),f(f),w(w){}
};
vector<ee> vec[maxn];
priority_queue<pli,vector<pli>,greater<pli> > que;
void dij() {
    memset(fa,-1,sizeof fa);
    for (int i=0;i<n;++i)
        d[i]=inf;
    d[s]=0;
    que.push(pli(0,s));
    while (!que.empty()) {
        pli tp=que.top();
        que.pop();
        int u=tp.snd;
        ll td=tp.fst;
        if (td>d[u])
            continue;
        for (uii i=0;i<vec[u].size();++i) {
            int v=vec[u][i].v;
            ll c=vec[u][i].w;
            if (d[v]>d[u]+c) {
                d[v]=d[u]+c;
                fa[v]=pii(u,i);
                que.push(pli(d[v],v));
            }
        }
    }
}
bool fil(int u) {
    while (fa[u].fst!=-1) {
        ee &te=vec[fa[u].fst][fa[u].snd];
        if (te.f==true) {
            te.w+=L-d[t];
            vec[te.v][te.id].w+=L-d[t];
            return true;
        }
        u=fa[u].fst;
    }
    return false;
}
int main()
{
    scanf("%d%d%lld%d%d",&n,&m,&L,&s,&t);
    for (int i=0;i<m;++i) {
        scanf("%d%d%lld",&u,&v,&w);
        vec[u].push_back(ee(u,v,vec[v].size(),!w,max(1LL,w)));
        vec[v].push_back(ee(v,u,vec[u].size()-1,!w,max(1LL,w)));
    }
    while (true) {
        dij();
        if (!(d[t]<L&&fil(t)))
            break;
    }
    if (d[t]!=L)
        puts("NO");
    else {
        puts("YES");
        for (int i=0;i<n;++i)
            for (uii j=0;j<vec[i].size();++j) {
                int u=vec[i][j].u,v=vec[i][j].v;
                ll w=vec[i][j].w;
                if (st.find(pii(min(u,v),max(u,v)))==st.end()) {
                    printf("%d %d %lld\n",u,v,w);
                    st.insert(pii(min(u,v),max(u,v)));
                }
            }
    }
    return 0;
}

删掉不在当前 【可能的】 最短路上的可变边能使程序更快一点。见pre()函数。但若AB点间有许多可变边均在可能的最短路上，时间效率没有太高的优化，1185ms。

#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
#include <set>
#include <algorithm>
using namespace std;
#define fst first
#define snd second
typedef long long ll;
typedef unsigned int uii;
typedef pair<ll,int> pli;
typedef pair<int,int> pii;
const ll inf=1e15;
const int maxn=1005;
const int maxm=10005;
int n,m,s,t,u,v;
set<pii> st;
ll w,d[maxn],L;
pii fa[maxn];
struct ee {
    int u,v,id;
    bool f;
    ll w;
    ee(){}
    ee(int u,int v,int id,bool f,ll w):u(u),v(v),id(id),f(f),w(w){}
};
vector<ee> vec[maxn];
priority_queue<pli,vector<pli>,greater<pli> > que;
void dij() {
    memset(fa,-1,sizeof fa);
    for (int i=0;i<n;++i)
        d[i]=inf;
    d[s]=0;
    que.push(pli(0,s));
    while (!que.empty()) {
        pli tp=que.top();
        que.pop();
        int u=tp.snd;
        ll td=tp.fst;
        if (td>d[u])
            continue;
        for (uii i=0;i<vec[u].size();++i) {
            int v=vec[u][i].v;
            ll c=vec[u][i].w;
            if (d[v]>d[u]+c) {
                d[v]=d[u]+c;
                fa[v]=pii(u,i);
                que.push(pli(d[v],v));
            }
        }
    }
}
bool fil(int u) {
    while (fa[u].fst!=-1) {
        ee &te=vec[fa[u].fst][fa[u].snd];
        if (te.f==true) {
            te.w+=L-d[t];
            vec[te.v][te.id].w+=L-d[t];
            return true;
        }
        u=fa[u].fst;
    }
    return false;
}
void pre() {
    dij();
    for (int i=0;i<n;++i)
        for (uii j=0;j<vec[i].size();++j) {
            int u=vec[i][j].u,v=vec[i][j].v;
            ll w=vec[i][j].w;
            if (vec[i][j].f&&max(d[v],d[u])!=min(d[v],d[u])+w)
                vec[i][j].w=inf;
        }
}
int main()
{
    scanf("%d%d%lld%d%d",&n,&m,&L,&s,&t);
    for (int i=0;i<m;++i) {
        scanf("%d%d%lld",&u,&v,&w);
        vec[u].push_back(ee(u,v,vec[v].size(),!w,max(1LL,w)));
        vec[v].push_back(ee(v,u,vec[u].size()-1,!w,max(1LL,w)));
    }
    pre();
    while (true) {
        dij();
        if (!(d[t]<L&&fil(t)))
            break;
    }
    if (d[t]!=L)
        puts("NO");
    else {
        puts("YES");
        for (int i=0;i<n;++i)
            for (uii j=0;j<vec[i].size();++j) {
                int u=vec[i][j].u,v=vec[i][j].v;
                ll w=vec[i][j].w;
                if (st.find(pii(min(u,v),max(u,v)))==st.end()) {
                    printf("%d %d %lld\n",u,v,w);
                    st.insert(pii(min(u,v),max(u,v)));
                }
            }
    }
    return 0;
}

删掉不在当前选定最短路上的可变边能使程序更快上许多。因为这里最短路上最多只有n-1条边。最多跑n-1次dij，时间复杂度O（nmlogn），342ms。

#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
#include <set>
#include <algorithm>
using namespace std;
#define fst first
#define snd second
typedef long long ll;
typedef unsigned int uii;
typedef pair<ll,int> pli;
typedef pair<int,int> pii;
const ll inf=1e15;
const int maxn=1005;
const int maxm=10005;
int n,m,s,t,u,v,a,b;
bool vis[maxn][maxn];
set<pii> st;
ll w,d[maxn],L;
pii fa[maxn];
struct ee {
    int u,v,id;
    bool f;
    ll w;
    ee(){}
    ee(int u,int v,int id,bool f,ll w):u(u),v(v),id(id),f(f),w(w){}
};
vector<ee> vec[maxn];
priority_queue<pli,vector<pli>,greater<pli> > que;
void dij() {
    memset(fa,-1,sizeof fa);
    for (int i=0;i<n;++i)
        d[i]=inf;
    d[s]=0;
    que.push(pli(0,s));
    while (!que.empty()) {
        pli tp=que.top();
        que.pop();
        int u=tp.snd;
        ll td=tp.fst;
        if (td>d[u])
            continue;
        for (uii i=0;i<vec[u].size();++i) {
            int v=vec[u][i].v;
            ll c=vec[u][i].w;
            if (d[v]>d[u]+c) {
                d[v]=d[u]+c;
                if (fa[v].fst!=-1) {
                    a=fa[v].fst,b=fa[v].snd;
                    vis[a][b]=false;
                    vis[vec[a][b].v][vec[a][b].id]=false;
                }
                fa[v]=pii(u,i);
                vis[u][i]=true;
                vis[vec[u][i].v][vec[u][i].id]=true;
                que.push(pli(d[v],v));
            }
        }
    }
}
bool fil(int u) {
    while (fa[u].fst!=-1) {
        ee &te=vec[fa[u].fst][fa[u].snd];
        if (te.f==true) {
            te.w+=L-d[t];
            vec[te.v][te.id].w+=L-d[t];
            return true;
        }
        u=fa[u].fst;
    }
    return false;
}
void pre() {
    dij();
    for (int i=0;i<n;++i)
        for (uii j=0;j<vec[i].size();++j)
            if (vec[i][j].f&&!vis[i][j])
                vec[i][j].w=inf;
}
int main()
{
    scanf("%d%d%lld%d%d",&n,&m,&L,&s,&t);
    for (int i=0;i<m;++i) {
        scanf("%d%d%lld",&u,&v,&w);
        vec[u].push_back(ee(u,v,vec[v].size(),!w,max(1LL,w)));
        vec[v].push_back(ee(v,u,vec[u].size()-1,!w,max(1LL,w)));
    }
    pre();
    while (true) {
        dij();
        if (!(d[t]<L&&fil(t)))
            break;
    }
    if (d[t]!=L)
        puts("NO");
    else {
        puts("YES");
        for (int i=0;i<n;++i)
            for (uii j=0;j<vec[i].size();++j) {
                int u=vec[i][j].u,v=vec[i][j].v;
                ll w=vec[i][j].w;
                if (st.find(pii(min(u,v),max(u,v)))==st.end()) {
                    printf("%d %d %lld\n",u,v,w);
                    st.insert(pii(min(u,v),max(u,v)));
                }
            }
    }
    return 0;
}

题解里说有人在比赛时写了一个二分的代码，学习了一发发现有道理。

首先二分可变边的数目p，1-p置为1，p到k置为inf。找出需要置为1的最少可变边的数目。此部分复杂度O（mlognlogm）

得到p后，二分第p条需要改成的值。此部分复杂度O（mlognlogL）

总时间复杂度O（mlogn（logL+logm）），42ms

#include <bits/stdc++.h>
using namespace std;
#define fst first
#define snd second
typedef long long ll;
typedef pair<ll,int> pli;
typedef pair<int,int> pii;
typedef unsigned int uii;
const int maxn=1005;
const ll inf=1e15;
int n,m,s,t,u,v,tot,l,r,mid,res=-1,to;
ll L,w,d[maxn],tr;
bool vis[maxn][maxn];
vector<pli> vec[maxn];
vector<pii> det;
priority_queue<pli,vector<pli>,greater<pli> > que;
void dij() {
    for (int i=0;i<n;++i)
        d[i]=inf;
    d[s]=0;
    que.push(pli(0LL,s));
    while (!que.empty()) {
        int u=que.top().snd;
        ll td=que.top().fst;
        que.pop();
        if (td>d[u])
            continue;
        for (uii i=0;i<vec[u].size();++i) {
            int v=vec[u][i].snd;
            ll c=vec[u][i].fst;
            if (d[v]>d[u]+c) {
                d[v]=d[u]+c;
                que.push(pli(d[v],v));
            }
        }
    }
}
bool check(int mid) {
    for (int i=0;i<(mid<<1);++i)
        vec[det[i].fst][det[i].snd].fst=1;
    for (uii i=mid<<1;i<det.size();++i)
        vec[det[i].fst][det[i].snd].fst=inf;
    dij();
    if (d[t]>L)
        return false;
    return true;
}
ll c2(int mid) {
    if (res>=0) {
        vec[det[res<<1].fst][det[res<<1].snd].fst=mid;
        vec[det[(res<<1)|1].fst][det[(res<<1)|1].snd].fst=mid;
    }
    dij();
    return d[t];
}
int main()
{
    scanf("%d%d%lld%d%d",&n,&m,&L,&s,&t);
    for (int i=0;i<m;++i) {
        scanf("%d%d%lld",&u,&v,&w);
        vec[u].push_back(pli(w,v));
        vec[v].push_back(pli(w,u));
        if (!w) {
            det.push_back(pii(u,vec[u].size()-1));
            det.push_back(pii(v,vec[v].size()-1));
        }
    }
    tot=det.size()>>1;
    l=0,r=tot;
    while (l<=r) {
        mid=(l+r)>>1;
        if (check(mid)) {
            res=mid;
            r=mid-1;
        } else
            l=mid+1;
    }
    if (res==-1)
        puts("NO");
    else {
        --res;
        l=0,r=L;
        while (l<=r) {
            mid=(l+r)>>1;
            tr=c2(mid);
            if (tr==L)
                break;
            else if (tr<L)
                l=mid+1;
            else
                r=mid-1;
        }
        if (l>r)
            puts("NO");
        else {
            puts("YES");
            for (int i=0;i<n;++i)
                for (uii j=0;j<vec[i].size();++j) {
                    to=vec[i][j].snd;
                    if (!vis[i][to]) {
                        vis[i][to]=vis[to][i]=true;
                        printf("%d %d %lld\n",i,to,vec[i][j].fst);
                    }
                }
        }
    }
    return 0;
}


QQ小炫
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Codeforces 716D Complete The Graph(最短路+思维）
GYH0730的博客
10-04 300
D. Complete The Graph time limit per test 4 seconds memory limit per test 256 megabytes input standard input output standard output ZS the Coder has drawn an undirected graph of n vertices nu...
Codeforces 716D D. Complete The Graph
blanKey的博客
09-21 672
题目连接：http://codeforces.com/contest/716/problem/D D. Complete The Graph time limit per test 4 seconds memory limit per test 256 megabytes input standard input output st
Codeforces 990D 图论+思维
PiscesCrab的博客
06-14 470
D. Graph And Its Complementtime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputGiven three numbers n,a,bn,a,b. You need to find an adjacency matrix of...
Codeforces Round #372 (Div. 2) D. Complete The Graph 图论、最短路、Dijkstra、路径、分配部分边权
ProLights的博客
09-23 1625
图论、最短路、Dijkstra、路径、分配部分边权 首先去点2种不可能的情况： 1、不记录w == 0 的边的情况下，求出dis[e]， 如果 dis[e] < L， 则 w == 0 的边无论怎样分配权值，src 到 e 的最短路 都是这个 dis[e]， ans = “NO"; 2、把w == 0 的边赋值为1，然后把这些 w == 0的边记录下来，跑一边 Dijkstra，如果 dis[e] > L， 则 由于 w > 0 即 w >= 1， 则无论怎样dis[e] 都大于 L， ans = ”NO“
Codeforces - 图论题目（难度：2200）
Nitrogens的博客
10-03 1337
Codeforces - 图论题目（难度：2200） AC 之后不写题解，赛前火葬场！！ 1. 507E - Breaking Good（最短路 + 松弛条件改造） 题目链接：https://codeforces.com/contest/507/problem/E 1.1 题意 给你一个 n(2≤n≤105)n(2 \le n\le 10^5)n(2≤n≤105) 个点和 m(0≤m≤min⁡(n...
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Codeforces Round #630 (Div. 2) D. Walk on Matrix（构造）
01-03
上面代码跑出来的dp[n][m]是0，然后从（1，1）（1，2）（2，2）（2，3）这样的相与值是k (看懂ans+k是啥应该就懂了) 代码： int main() { std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0); int ans=(1&...
Codeforces Round #627 (Div. 3) D. Pair of Topics（二分，思维）
01-03
传送门 题意： The pair of topics
Codeforces Round #627 (Div. 3) C. Frog Jumps（思维）
01-20
每步只能跳d 在1——n每个位置有方向，L,R，求d的最小值 思路： 只用找相邻两个R之间的最大值即可 代码： #include #include #include #include #include #include #include #include #include #include #define ...
Codeforces Round #628 (Div. 2) D. Ehab the Xorcist（异或构造，思维）
01-03
传送门 题意： 给两个整数u,v，构造一个数组，使得数组的异或和等于u,数组的和等于v 要求构造的数组尽可能的短 思路： 对于每种情况讨论输出即可，注意几种情况的特判 看代码应该能明白 代码： ...
codeforces 715 B Complete The Graph（二分+最短路）
TelmaZzzz的博客
04-30 195
题解： 题意大致为给定1e31e31e3的无向图，且给定起点sss和终点ttt，以及部分知道长度的边，让你补全不知道长度的边使得从sss到ttt的最短路为LLL 解题可以分为3个步骤 不将不知道长度的边跳过，求最短路，若最短路小于L则一定不可能成功输出NO，若等于则将未知边长设定为INF若大于则执行2 将所有未知边都设成1，跑最短路，若最短路大于L则一定不能成功（因为题意规定边长最小为1）输出N...
Codeforces Round #372 (Div. 1) B. Complete The Graph 解题报告
Alisan_wan的博客
09-18 818
Codeforces Round #372 (Div. 1) B. Complete The Graph 解题报告
Codeforces Round #372 (Div. 2) -- D. Complete The Graph（Dijkstra单源最短路）
aozil_yang的博客
09-18 1136
大体题意： 给你一个无向图，有n 个顶点和m 个边，一些边的权重是正数，一些边的权重是0，表示已经删除，告诉你起始位置和终止位置和最短路L，要求把已经删除的边（权值为0）重建，自己赋值，使得最短路依然是L。 思路： 单源最短路，其实想清楚了还是很简单的！ 先求一遍最短路，当发现最短路L2  小于L时，那么肯定是无解的，因为你此时最短路已经小于L了，在加入一些重建的边，只能会越来越小，因此不
CodeForces 715B Complete The Graph
Akakii的博客
12-11 434
题目大意 给定一张n个点，m条边的无向图，其中有一些边权未知。 给定一个起点s和一个终点t，以及它们之间的最短路，要求输出一种方案使得这个最短路成立。 Data Constraint n≤2000,m≤10000
codeforces 716D. Complete The Graph(最短路)
小小西北风
09-21 1342
D. Complete The Graph time limit per test 4 seconds memory limit per test 256 megabytes input standard input output standard output ZS the Coder has drawn an undirected
CCF CSP 201703-5 引水入城 (100分)
亂丟程式碼的天空
03-20 1457
DP 复杂度是O(N^2)的。最后一组数据T掉了，改天再改改吧。UPD：过了最后一组，开了编译器优化，并且将数组的两个维度换了一下，利用了局部防存。// 90 points #pragma GCC optimize("Ofast") #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native") #...
2016 大连 K Guess the number HDU 5981 DP 打表找规律
亂丟程式碼的天空
04-02 1204
弄清楚n^2 DP之后，打表能发现l与r随着n的增大是有规律的。用sum维护一下f的前缀和，就可以很快求出答案。 #include #include #include using namespace std; const int mod=1e8+73; const int maxn=5e6+1; int a,b,dp[maxn],n,f[maxn],sum[maxn]; int main(
Codeforces 835E E. The penguin's game 交互题 多猪试毒
亂丟程式碼的天空
08-01 1153
给定n(2 解法：题目给出的19次询问次数上限是严格的。即能构造数据使得不得不询问19次才能出答案。 先讨论出询问的集合元素个数的奇偶性和y个数的奇偶性返回的答案分别是什么。一共有四种情况，用（集合个数，y的个数，答案）表示的话，即有： （偶数，偶数，0），（偶数，奇数，x xor y），（奇数，偶数，x），（奇数，奇数，y），因为x与y非零且互不相等，故0，x，y，x xor y互不相等。
HDU 6059 Kanade's trio 字典树
亂丟程式碼的天空
08-02 1034
给n个数，要求(i,j,k)的对数，满足ai xor aj 解法：还是欠缺了一些 counting 的姿势啊，比赛的时候想错了，写了个假算法。 T有20组，n的范围是5e5，考虑O(n)或者O(nlog x)形式的算法。发现，通过字典树，可以枚举j，对每个j，用O(log MAX_INT)的时间复杂度求出i与k的对数。 如何求i与k的对数呢？可以从高到低枚举 aj 的每一位。如果该位为1，
codeforces round #792 (div. 1 + div. 2)
最新发布
06-06
codeforces round #792 (div. 1 + div. 2) 是 Codeforces 竞赛平台上的一场比赛，包括两个级别：div. 1 和 div. 2。这场比赛通常会有多个问题需要参赛者解决，每个问题都有不同的难度等级。参赛者需要在规定的时间内...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值