BZOJ 5335 智力竞赛

最新推荐文章于 2019-08-08 19:33:00 发布
最新推荐文章于 2019-08-08 19:33:00 发布
阅读量293 收藏
点赞数
分类专栏： 图论 二分图匹配 文章标签： 图论 二分图匹配
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/meopass/article/details/82905853
版权

大致题意：给出一个DAG，问能否用n+1条可重复路径覆盖整个图。

最小有重复路径覆盖问题，先传递闭包，转化成无重复路径覆盖问题。
然后把原图每个点拆成两个点建立二分图，然后用原图点数 − - −最大匹配数就是答案。
如果可以覆盖就输出 A K AK AK，否则二分一个最大可行权值 m i d mid mid，大于 m i d mid mid的点连一个 i − > i i -> i i−>i的边，表示忽略这个点，然后照常建图即可。

#define others
#ifdef poj
#include <iostream>
#include <cstring>
#include <cmath>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <string>
#include <map>
#include <set>
#endif // poj
#ifdef others
#include <bits/stdc++.h>
#include <ext/rope>
#include <ext/pb_ds/priority_queue.hpp>
#endif // others
//#define file
#define all(x) x.begin(), x.end()
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
#define eps 1e-8
const double pi = acos(-1.0);


typedef long long LL;
typedef long long DLL;
typedef unsigned long long ULL;
void umax(LL &a, LL b) {
    a = max(a, b);
}
void umin(LL &a, LL b) {
    a = min(a, b);
}
int dcmp(double x) {
    return fabs(x) <= eps?0:(x > 0?1:-1);
}
void file() {
    freopen("data_in.txt", "r", stdin);
    freopen("data_out.txt", "w", stdout);
}

DLL mod = 1e9;

DLL Pow(DLL a,DLL b) {
    DLL res=1;
    a%=mod;
    for(; b; b>>=1) {
        if(b&1)res=res*a%mod;
        a=a*a%mod;
    }
    return res;
}
//
//void print(DLL x) {
//    if(x < 0) {
//        x = -x;
//        putchar('-');
//    }
//    if(x > 9) print(x/10);
//    putchar(x%10 + '0');
//}
//#define iostart
//#define iostart
#define pb(x) push_back(x)
namespace solver {
    const int maxn = 510;
    int n, m;
    int g[maxn][maxn];
    vector<int> G[maxn];
    int link[maxn], vis[maxn];
    int v[maxn];
    bool dfs(int u) {
        for(int i = 0; i < G[u].size(); i++) {
            int v = G[u][i];
            if(!vis[v]) {
                vis[v] = 1;
                if(link[v] == -1 || dfs(link[v])) {
                    link[v] = u;
                    return 1;
                }
            }
        }
        return 0;
    }
    int gao() {
        int ans = 0;
        memset(link, -1, sizeof link);
        for(int i = 1; i <= m; i++) {
            memset(vis, 0, sizeof vis);
            if(dfs(i))
                ans++;
        }
        return ans;
    }
    bool check_val(int x) {
        for (int i = 1; i <= m; i++) {
            G[i].clear();
        }
        for (int i = 1; i <= m; i++){
            if (v[i] > x) {
                G[i].push_back(i);
            }
            for (int j = 1; j <= m; j++){
                if (g[i][j]) {
                    G[i].push_back(j);
//                    cout << i << " xx " << j << endl;
                }
            }
        }
        int match = gao();
//        cout << x << " " << m - match << endl;
        return m - match <= n + 1;
    }
    vector<int> hash_val;
    void solve() {
        scanf("%d%d", &n, &m);
        for (int i = 1; i <= m; i++){
            int val, k;
            scanf("%d%d", &val, &k);
            v[i] = val;
            hash_val.push_back(val);
            while (k--) {
                int to;
                scanf("%d", &to);
                g[i][to] = 1;
            }
        }
        for (int k = 1; k <= m; k++) {
            for (int i = 1; i <= m; i++) {
                for (int j = 1; j <= m; j++) {
                    if (g[i][k] && g[k][j]) {
                        g[i][j] = 1;
                    }
                }
            }
        }
        sort(all(hash_val));
        hash_val.erase(unique(all(hash_val)), hash_val.end());
        int L = 0, R = (int)hash_val.size() - 2, M;
        while (L + 4 < R) {
            M = L + R >> 1;
            if (check_val(hash_val[M])) {
                L = M;
            } else {
                R = M;
            }
        }
        for (; L < R; L++) {
            if (!check_val(hash_val[L]))
                break;
        }
        if (check_val(hash_val[L])) {
            puts("AK");
        } else {
            printf("%d\n", hash_val[L]);
        }
    }
}

int main() {
#ifdef iostart
    ios::sync_with_stdio(0);
    cin.tie(0);
#endif // iostart
//    file();
    solver::solve();
    return 0;
}

由于传递闭包之后是一个稠密图，所以可以用bitset去优化匈牙利算法。

#define others
#ifdef poj
#include <iostream>
#include <cstring>
#include <cmath>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <string>
#include <map>
#include <set>
#endif // poj
#ifdef others
#include <bits/stdc++.h>
#include <ext/rope>
#include <ext/pb_ds/priority_queue.hpp>
#endif // others
//#define file
#define all(x) x.begin(), x.end()
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
#define eps 1e-8
const double pi = acos(-1.0);


typedef long long LL;
typedef long long DLL;
typedef unsigned long long ULL;
void umax(LL &a, LL b) {
    a = max(a, b);
}
void umin(LL &a, LL b) {
    a = min(a, b);
}
int dcmp(double x) {
    return fabs(x) <= eps?0:(x > 0?1:-1);
}
void file() {
    freopen("data_in.txt", "r", stdin);
    freopen("data_out.txt", "w", stdout);
}

DLL mod = 1e9;

DLL Pow(DLL a,DLL b) {
    DLL res=1;
    a%=mod;
    for(; b; b>>=1) {
        if(b&1)res=res*a%mod;
        a=a*a%mod;
    }
    return res;
}
//
//void print(DLL x) {
//    if(x < 0) {
//        x = -x;
//        putchar('-');
//    }
//    if(x > 9) print(x/10);
//    putchar(x%10 + '0');
//}
//#define iostart
//#define iostart
#define pb(x) push_back(x)
namespace solver {
    const int maxn = 510;
    int n, m;
    int g[maxn][maxn];
    int a[maxn][maxn/32+1], b[maxn][maxn/32+1];
    int link[maxn], vis[maxn];
    int q[maxn];

    typedef int U;
    int tot = m >> 5;
    inline void set1(U v[],int x){v[x>>5]|=1U<<(x&31);}
    inline void flip(U v[],int x){v[x>>5]^=1U<<(x&31);}
    bool dfs(int u) {
        for (int i = 0; i <= tot; i++) {
            for (;;) {
                U o = b[u][i]&vis[i];
                if (!o) break;
                int y = i<<5|__builtin_ctz(o);
                flip(vis, y);
                if (!link[y] || dfs(link[y])) return link[y]=u, 1;
            }
        }
        return 0;
    }
    int gao() {
        for (int i = 1; i <= m; i++) link[i] = 0;
        int ans = 0;
        for(int i = 1; i <= m; i++) {
            for (int j = 1; j <= m; j++) set1(vis, j);
            if(dfs(i)) ans++;
        }
        return ans;
    }
    bool check_val(int x) {
        for (int i = 1; i <= m; i++){
            for (int j = 0; j <= tot; j++) {
                b[i][j] = a[i][j];
            }
        }
        for (int i = 1; i <= m; i++) {
            if (q[i] > x) {
                set1(b[i], i);
            }
        }
        for (int i = 1; i <= m; i++) link[i] = 0;
        int match = gao();
        return m - match <= n + 1;
    }
    vector<int> hash_val;
    void solve() {
        scanf("%d%d", &n, &m);
        tot = m >> 5;
        for (int i = 1; i <= m; i++){
            int val, k;
            scanf("%d%d", &val, &k);
            q[i] = val;
            hash_val.push_back(val);
            while (k--) {
                int to;
                scanf("%d", &to);
                g[i][to] = 1;
            }
        }
        for (int k = 1; k <= m; k++) {
            for (int i = 1; i <= m; i++) {
                for (int j = 1; j <= m; j++) {
                    if (g[i][k] && g[k][j]) {
                        g[i][j] = 1;
                    }
                }
            }
        }
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= m; j++) {
                if (g[i][j])
                    set1(a[i], j);
            }
        }
        sort(all(hash_val));
        hash_val.erase(unique(all(hash_val)), hash_val.end());
        int L = 0, R = (int)hash_val.size() - 2, M;
        while (L + 4 < R) {
            M = L + R >> 1;
            if (check_val(hash_val[M])) {
                L = M;
            } else {
                R = M;
            }
        }
        for (; L < R; L++) {
            if (!check_val(hash_val[L]))
                break;
        }
        if (check_val(hash_val[L])) {
            puts("AK");
        } else {
            printf("%d\n", hash_val[L]);
        }
    }
}

int main() {
#ifdef iostart
    ios::sync_with_stdio(0);
    cin.tie(0);
#endif // iostart
//    file();
    solver::solve();
    return 0;
}
meopass
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
任意竞赛图都有哈密顿path(A Tournament has a Hamiltonian path)
unsolvedmys的博客
06-22 6006
设G是竞赛图，即完全图的一个定向。则G必有哈密顿path. 证明： 反证。设n=|V|， 且P={1,2,3,…,k}(k<n)P=\{1,2,3,\dots,k\}(k<n)是G中的最长path. 则对任取的a∉Pa\notin P, 我们有下图 如果a和1a\textrm{和}1之间的边为(a,1)(a,1)，那么把 aa 添加进P的开头就是一条比P更长的path，这样矛盾。同理
wangjunrui666#bzoj-problem##5335. [TJOI2018]智力竞赛1
07-25
比赛规则如下:一共有m道题目，每个入都有1次答题机会，每次答题为选择一道题目回答，在回答正确后，可以从这个题目的后续题目，直达题目答错题目或者没有后续题目。其中
【BZOJ】5219: [Lydsy2017省队十连测]最长路径 组合计数&竞赛图性质
远行客
09-22 445
传送门：bzoj5219 题解 竞赛图性质： 必然存在一条哈密尔顿路径 缩点之后按拓扑序形成一条“链” 由竞赛图性质得到从点1出发的最长路径上点数等于1所在sccsccscc点数+拓扑序在1(链中靠后)的sccsccscc的点的总数。 f[n]f[n]f[n]表示有nnn个节点的竞赛图的个数，显然：f[n]=2n(n−1)2f[n]=2^{\frac{n(n-1)}{2}}f[n]=22n(...
bzoj 4727 [POI2017]Turysta 竞赛图
make_it_for_good的博客
03-09 828
对于一个竞赛图： 一定存在哈密顿路径 如果强连通，一定存在哈密顿回路 tarjan缩点后得到的拓扑图是一条有向链，上方的点向下方的点连边。#include <bits/stdc++.h> using namespace std; #define N 2100 int n,top,scc,cnt; int mp[N][N],dfn[N],low[N],st[N],ins[N],bel[N]; i
【BZOJ】4727：[POI2017]Turysta-竞赛图&哈密顿回路
远行客
06-03 422
题解 一道好题。 根据竞赛图性质可得，我们一定能在图中找到哈密顿路径，然后再利用竞赛图性质寻找强连通分量，并不断扩展环的大小。（这一步参见神犇博客:哈密顿问题）。 我们根据推断出，每个scc（强连通分量）之间的连边必然是单向的（均为从某一scc的出边和另一scc的入边）。我们拓扑排序一下，对于每个点，先把它所在scc加入，再不断按拓扑序由大到小加入，就是答案了。 代码 #in...
BZOJ5219 [Lydsy2017省队十连测]最长路径（竞赛图+计数DP）
hzk_cpp的博客
07-14 270
题目：BZOJ5219. 题目大意：对于k∈[1,n]k\in [1,n]k∈[1,n]，求nnn个点的竞赛图中满足从111号点出发最长路径长度为kkk的不同的图的数量（点有编号）. 1≤n≤20001\leq n\leq 20001≤n≤2000. 这题不得不说还是一道很好的组合计数题，但是挺套路的. 首先，我们将点划分为两部分，一部分是不在111出发的最长路径上的，另一部分是在111出发的最长...
BZOJ第一部分
11-03
BZOJ，全称为“北京邮电大学在线评测系统”（Beijing Zhiyuan Online Judge），是中国最早的一批在线编程竞赛平台之一，它为编程爱好者提供了一个练习和检验编程技能的环境。在这个系统中，用户可以提交自己的代码来...
BZOJ全代码
02-05
BZOJ是一个在线编程竞赛平台，它提供了大量的算法题目供参赛者练习和提交代码，以检验编程能力与算法理解。 【描述】提到的"解压到一个文件夹在打开使用"，意味着用户需要先将这个压缩文件下载到本地，然后使用解...
bzoj problem
08-21
【标题】"bzoj problem" 指的是“八中OJ（Online Judge）问题集”，这是一个在线编程竞赛平台的题目合集。八中OJ可能是某所中学的在线编程训练系统，它提供了大量的编程题目供用户练习和挑战，以提升编程能力和算法...
BZOJ题目镜像
09-14
BZOJ是中国早期的在线编程竞赛平台，提供了大量的算法题目供编程爱好者进行训练和比赛。由于其服务器的负载或者维护，用户有时会遇到无法正常访问的情况，这时候BZOJ的镜像就起到了关键作用，它允许用户在BZOJ主站...
BZOJ 5219: [Lydsy2017省队十连测]最长路径 竞赛图组合计数
dilu0653的博客
08-08 240
title BZOJ 5219 Description 在Byteland一共有n个城市，编号依次为1到n，它们之间计划修建n(n-1)/2条单向道路，对于任意两个不同的点i和j，在它们之间有且仅有一条单向道路，方向要么是i到j，要么是j到i。换句话说，这是一个n个点的竞赛图。Byteasar居住在1号城市，他希望从1号城市出发，沿着单向道路不重复地访问一些城市，使得访问的城市数尽可能...
【BZOJ5335】【TJOI2018】智力竞赛
cz_xuyixuan的博客
06-12 446
【题目链接】点击打开链接【思路要点】二分答案，然后用有上下界的最小流验证答案。时间复杂度\(O(LogM*Dinic(M,\sum K_i))\)。【代码】#include&lt;bits/stdc++.h&gt; using namespace std; const int MAXN = 505; const int MAXP = 2005; const int INF = 1e9; templ...
bzoj5335: [TJOI2018]智力竞赛【二分+最小路径覆盖】
cdsszjj的博客
05-21 347
Description 小豆报名参加智力竞赛，他带上了n个好朋友作为亲友团一块来参加比赛。 比赛规则如下: 一共有m道题目，每个入都有1次答题机会，每次答题为选择一道题目回答，在回答正确后，可以从这个题目的后续 题目，直达题目答错题目或者没有后续题目。每个问题都会代表一个价值，比赛最后的参赛选手获得奖励价值等价 于该选手和他的亲友团没有回答的问题中的最低价值。我们现在知道小豆和他的亲友团...
[bzoj5335][loj2574][TJOI2018]智力竞赛【网络流】
D_Vanisher的博客
06-12 354
【题目链接】 　　https://loj.ac/problem/2574 【题解】 　　每次加入最小的点并判断是否可行，判断的方法是将每个点拆成入点和出点，加入时连一条下界为1的边，跑最小流。若最小流≤n+1≤n+1\leq n + 1则可行。 　　时间复杂度O(MV)O(MV)O(MV) (V为边数)(V为边数)(V为边数) 【代码】 # include &amp;lt;bits/stdc+...
BZOJ5335: [TJOI2018]智力竞赛
01-06 92
BZOJ5335: [TJOI2018]智力竞赛 https://lydsy.com/JudgeOnline/problem.php?id=5335 分析: 题意有两点需要注意: 回答过的题目还能再回答一次 图是个有向无环图(这怎么从题意中看出来？) 那么就好做了，二分答案之后转化成最小路径覆盖问题。 对于这类问题，我们一般的解法如下: 如果不可重复经过点，那么把每个点拆成两个...
bzoj 1612 floyd传递闭包
Eirlys的博客
03-07 352
题意：n个牛，给出m场比赛的比赛结果（前面的赢后面的），能力强的总是赢能力弱的，求最多有几头牛能确定能力排名 第一眼看题再看数据范围，第一反应不是网络流就是建有向边搞图... 当一个牛的能力可以确定时，当且仅当能赢它的牛加上输给它的牛有n-1头 可以发现，赢和输的信息是可以传递的 即当i能赢k且k能赢j时，i也能赢j。输的信息同理 这样我们就能找到所有能赢i的牛和输给i的牛 分别记录赢
NOI模拟（5.21） TJOID1T2 智力竞赛 （bzoj5335）
scarlyw的博客
05-22 310
floyed + 二分 + 可重点最小链覆盖
bzoj 5335: [TJOI2018]智力竞赛 二分+最小路径覆盖
wohenshuai
05-27 289
题意 小豆报名参加智力竞赛，他带上了n个好朋友作为亲友团一块来参加比赛。 比赛规则如下: 一共有m道题目，每个入都有1次答题机会，每次答题为选择一道题目回答，在回答正确后，可以从这个题目的后续题目，直达题目答错题目或者没有后续题目。每个问题都会代表一个价值，比赛最后的参赛选手获得奖励价值等价于该选手和他的亲友团没有回答的问题中的最低价值。我们现在知道小豆和他的亲友团实力非常强，能够做出这次竞...
bzoj5335 [TJOI2018]智力竞赛（Floyd+二分答案+匈牙利）
Icefox的博客
05-21 276
二分答案以后就是个最小路径覆盖。 注意要先Floyd传递闭包。 #include &lt;cstdio&gt; #include &lt;cstring&gt; #include &lt;algorithm&gt; using namespace std; #define ll long long #define inf 0x3f3f3f3f #define N 510 inline char...
bzoj做题计划 excel
最新发布
07-16
bzoj作为一个计算机竞赛的在线评测系统，不仅可以提供大量的题目供程序员练习和学习，还可以帮助程序员提升算法和编程能力。为了更好地利用bzoj进行题目的学习和刷题，制定一个bzoj做题计划是非常有必要的。 首先，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值