1703:发现它，抓住它

最新推荐文章于 2024-07-12 14:12:49 发布
最新推荐文章于 2024-07-12 14:12:49 发布
阅读量421 收藏 9
点赞数 5
文章标签： 图论 算法 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fool256353/article/details/140328024
版权

网址如下：

OpenJudge - 1703:发现它，抓住它

测，这题差点让我去世

用了一堆方法来做

后面现学了并查集，用了并查集来做，因为缩短路径的方法不好，还是超时了

后面换了一种缩短路径的方法

先上代码

解法一（TLE）

#include<cstdio>
#include<vector>
#include<cstring>
using namespace std;

const int maxn = 100001;

int kase[maxn], N, M;
vector<int> G[maxn];
bool vis[maxn];

void init(void){
    for(int i = 1; i <= N; i++) G[i].clear();
    memset(kase, -1, sizeof(kase));
}
void chg(int idx){
    vis[idx] = true;
    for(int i = 0; i < G[idx].size(); i++) if(!vis[G[idx][i]]) chg(G[idx][i]);
    kase[idx] = !kase[idx];
}
void fill(int idx, int b){
    vis[idx] = true;
    if(vis[b]) return;
    for(int i = 0; i < G[idx].size(); i++) if(!vis[G[idx][i]]) fill(G[idx][i], b);
}
void distinguish(int a, int b){
    if(kase[a] == -1 && kase[b] == -1){kase[a] = 0; kase[b] = 1;}
    else if(kase[a] == -1){kase[a] = !kase[b];}
    else if(kase[b] == -1){kase[b] = !kase[a];}
    else if(kase[a] == kase[b]){memset(vis, 0, sizeof(vis)); chg(a);}
    G[a].push_back(b); G[b].push_back(a);
}
void ans(int a, int b){
    if(kase[a] == -1 || kase[b] == -1) printf("Not sure yet.\n");
    else{
        memset(vis, 0, sizeof(vis));
        fill(a, b);
        if(vis[b]){
            if(kase[a] == kase[b]) printf("In the same gang.\n");
            else printf("In different gangs.\n");
        }
        else printf("Not sure yet.\n");
    }
}

int main(void)
{
    int T; scanf("%d", &T);
    while(T--){
        scanf("%d%d", &N, &M);
        init();
        while(M--){
            getchar(); char c = getchar();
            int a, b; scanf("%d%d", &a, &b);
            if(c == 'A') ans(a, b);
            else distinguish(a, b);
        }
    }
    
    return 0;
}

思路

我就是根据已有的情报直接假设哪几个案件是哪个团伙干的

只需要维护这几个案件的关系满足情报就行

但是因为是随意假设的，所以会出现假设完的两个案件与情报不符

这就要改变其中一个案件（0变1或1变0）

或者说“案件图”

因为D a b把这一片案件连起来了

所以都要改

同时，还有一种意外情况，两个案件不在同一个“案件图”上，案件都不为-1（代表未定义）

就需要事先判断二者在同一个“案件图”上


总结
我们需要做的：记录“情报图”，并维护案件的关系与情报相符
两个案件可以判断关系的前提条件：都定义了，且在同一个“情报图”上

但是TLE了

解法二（TLE）

#include<cstdio>
#include<cstring>
using namespace std;

const int maxn = 100001;

int kase[maxn], N, M;
int color[maxn];
int newcolor;

void init(void){
    memset(kase, -1, sizeof(kase));
    memset(color, 0, sizeof(color));
    newcolor = 1;
}
void paint(int Dst, int Src){
    for(int i = 1; i <= N; i++) if(color[i] == Src) color[i] = Dst;
}
void distinguish(int a, int b){
    if(kase[a] == -1 && kase[b] == -1){kase[a] = 0; kase[b] = 1; color[a] = color[b] = newcolor++;}
    else if(kase[a] == -1){kase[a] = !kase[b]; color[a] = color[b];}
    else if(kase[b] == -1){kase[b] = !kase[a]; color[b] = color[a];}
    else if(kase[a] == kase[b]){paint(color[a], color[b]);}
    
}
void ans(int a, int b){
    if(kase[a] == -1 || kase[b] == -1) printf("Not sure yet.\n");
    else{
        if(color[a] == color[b]){
            if(kase[a] == kase[b]) printf("In the same gang.\n");
            else printf("In different gangs.\n");
        }
        else printf("Not sure yet.\n");
    }
}

int main(void)
{
    int T; scanf("%d", &T);
    while(T--){
        scanf("%d%d", &N, &M);
        init();
        while(M--){
            getchar(); char c = getchar();
            int a, b; scanf("%d%d", &a, &b);
            if(c == 'A') ans(a, b);
            else distinguish(a, b);
        }
    }
    
    return 0;
}

思路

根据上面我所说的，我只是把一个“案件图”涂上了相同的颜色，来标记这些案件属于同一个“案件图”。这样，每次出现两个案件不在同一个“案件图”上，案件都不为-1（代表未定义）的情况，合并“案件图”就只需要把一个“案件图”的颜色涂成另一个“案件图”的

就不需要解法一的vector来记录图的结点之间的联系，减少了内存操作

但是每次重涂就需要遍历所有的案件

重涂数量多了就完蛋

最后还是TLE

解法三（TLE）

#include<cstdio>
#include<cstring>
using namespace std;

const int maxn = 100001;

int kase[maxn], N, M;
int color[maxn];
int head[maxn], next[maxn];
int newcolor;

void init(void){
    memset(kase, -1, sizeof(kase));
    memset(color, 0, sizeof(color));
    memset(head, 0, sizeof(head));
    memset(next, 0, sizeof(next));
    newcolor = 1;
}
inline void list_insert(int idx, int color){
    next[idx] = head[color];
    head[color] = idx;
}
void paint(int Dst, int Src){
    for(int i = head[Src]; i; i = next[i]){color[i] = Dst; kase[i] = !kase[i]; list_insert(i, Dst);}
}
void distinguish(int a, int b){
    if(kase[a] == -1 && kase[b] == -1){kase[a] = 0; kase[b] = 1; color[a] = color[b] = newcolor; list_insert(a, newcolor); list_insert(b, newcolor++);}
    else if(kase[a] == -1){kase[a] = !kase[b]; color[a] = color[b]; list_insert(a, color[b]);}
    else if(kase[b] == -1){kase[b] = !kase[a]; color[b] = color[a]; list_insert(b, color[a]);}
    else if(kase[a] == kase[b]){paint(color[a], color[b]);}
    
}
void ans(int a, int b){
    if(kase[a] == -1 || kase[b] == -1) printf("Not sure yet.\n");
    else{
        if(color[a] == color[b]){
            if(kase[a] == kase[b]) printf("In the same gang.\n");
            else printf("In different gangs.\n");
        }
        else printf("Not sure yet.\n");
    }
}

int main(void)
{
    int T; scanf("%d", &T);
    while(T--){
        scanf("%d%d", &N, &M);
        init();
        while(M--){
            getchar(); char c = getchar();
            int a, b; scanf("%d%d", &a, &b);
            if(c == 'A') ans(a, b);
            else distinguish(a, b);
        }
    }
    
    return 0;
}

思路

那优化就很简单了，既然每次重涂都需要遍历所有元素，那么我建立链表，将需要改变的案件记录起来就行了

但是还是TLE，因为数据太大了

解法四（TLE）

#include<cstdio>
#include<cstring>
using namespace std;

const int maxn = 100001;

int condition[maxn], N, M;
int parent[maxn], rank[maxn];
int newcolor;

void init(void){
    memset(condition, 0, sizeof(condition));
    memset(rank, 1, sizeof(rank));
    for(int i = 1; i <= N; i++) parent[i] = i;
    newcolor = 1;
}
int find(int idx){
    if(parent[idx] == idx) return idx;
    return find(parent[idx]);
}
int get_relation(int idx){
    if(parent[idx] == idx) return 0;
    return get_relation(parent[idx]) ^ condition[idx];
}
void join(int idx1, int idx2){
    int prt1 = find(idx1), prt2 = find(idx2);
    if(prt1 == prt2) return;
    int r1 = get_relation(idx1), r2 = get_relation(idx2);
    if(rank[prt1] < rank[prt2]){parent[prt1] = prt2; condition[prt1] = !(r1 ^ r2);}
    else{
        if(rank[prt1] == rank[prt2]) rank[prt2]++;
        parent[prt2] = prt1; condition[prt2] = !(r1 ^ r2);
    }
}
void ans(int a, int b){
    int prt1 = find(a), prt2 = find(b);
    if(prt1 != prt2) printf("Not sure yet.\n");
    else{
        int r1 = get_relation(a), r2 = get_relation(b);
        if(r1 == r2) printf("In the same gang.\n");
        else printf("In different gangs\n");
    }
}

int main(void)
{
    int T; scanf("%d", &T);
    while(T--){
        scanf("%d%d", &N, &M);
        init();
        while(M--){
            getchar(); char c = getchar();
            int a, b; scanf("%d%d", &a, &b);
            if(c == 'A') ans(a, b);
            else join(a, b);
        }
    }
    
    return 0;
}

思路

考虑到上面的图的特点：不相交，并且需要合并，还要查找元素的关系

然后我去学了并查集

可以看看这篇博客：【算法与数据结构】—— 并查集-CSDN博客

讲的非常简单易懂

然后我用了并查集，并使用了上面那篇博客里面讲的第二种的缩短路径的方法

其中condition记录案件和父案件的关系

parent和rank的意义见上面那篇博客

然后

还是TLE

我差点裂了

解法五（AC）

#include<cstdio>
#include<cstring>
using namespace std;

const int maxn = 100001;

int condition[maxn], N, M;
int parent[maxn];
int newcolor;

void init(void){
    memset(condition, 0, sizeof(condition));
    for(int i = 1; i <= N; i++) parent[i] = i;
}
int find(int idx){
    if(parent[idx] == idx) return idx;
    int par = parent[idx];
    while(parent[par] != par){
        condition[idx] = condition[idx] ^ condition[par];
        parent[idx] = parent[par];
        par = parent[idx];
    }
    return find(parent[idx]);
}
void join(int idx1, int idx2){
    int prt1 = find(idx1), prt2 = find(idx2);
    if(prt1 == prt2) return;
    parent[prt1] = prt2;
    condition[prt1] = !(condition[idx1] ^ condition[idx2]);
}
void ans(int a, int b){
    int prt1 = find(a), prt2 = find(b);
    if(prt1 != prt2) printf("Not sure yet.\n");
    else{
        if(condition[a] == condition[b]) printf("In the same gang.\n");
        else printf("In different gangs.\n");
    }
}

int main(void)
{
    int T; scanf("%d", &T);
    while(T--){
        scanf("%d%d", &N, &M);
        init();
        while(M--){
            getchar(); char c = getchar();
            int a, b; scanf("%d%d", &a, &b);
            if(c == 'A') ans(a, b);
            else join(a, b);
        }
    }
    
    return 0;
}

思路

最后就是这玩意了

用到了上述博客提到的缩短路径的第一种方法

condition的意义和解法四的一样

最后AC了

Fool256353
关注
  • 5
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
种类并查集 发现它 抓住它
xutian_curry的博客
05-16 1412
tag[i] 表示 i 结点 与其父节点是否在同一个集合中（表示的是一种相对关系）GetFather时：压缩路径，同时更新tag[i]合并时：更新tag[father[i]]#include &lt;stdio.h&gt; #include &lt;iostream&gt; #include &lt;stack&gt; #include &lt;string&gt; #include &lt;se...
发现它，抓住它－－并查集，偏序关系
melanieecd的博客
08-10 715
POJ 1703 总时间限制: 1000ms 内存限制: 65536kB 描述 一个城市中有两个犯罪团伙A和B，你需要帮助警察判断任意两起案件是否是同一个犯罪团伙所为，警察所获得的信息是有限的。假设现在有N起案件（N<=100000），编号为1到N，每起案件由团伙A或团伙B所为。你将按时间顺序获得M条信息（M<=100000），这些信息分为两类： 1. D [a] [b] 其中[a]和[
POJ-1703:发现它，抓住它 -关系并查集的基本运用+坑点分析
csyifanZhang的博客
02-25 1150
又写了一个并查集，runtime error多次，最后玄学AC。 原题传送门 这道题其实与食物链题解非常之像 难度比食物链稍低，这里的难点在于并查集只能进行集合之间的合并，如何操作能正确的合并不同组的犯罪团伙呢？ 答案是开两倍的数组，0-nnn的kind[i]kind[i]kind[i]表示iii属于一类罪犯，n+1−2nn+1-2nn+1−2n的kind[i]kind[i]kind[i]表示ii...
带权并查集——发现它，抓住它
weixin_51700788的博客
12-23 388
1703:发现它，抓住它 查看 提交 统计 提示 提问 总时间限制: 1000ms 内存限制: 65536kB 描述 一个城市中有两个犯罪团伙A和B，你需要帮助警察判断任意两起案件是否是同一个犯罪团伙所为，警察所获得的信息是有限的。假设现在有N起案件（N<=100000），编号为1到N，每起案件由团伙A或团伙B所为。你将按时间顺序获得M条信息（M<=100000），这些信息分为两类： 1. D [a] [b] 其中[a]和[b]表示两起案件的编号，这条信息表...
发现它，抓住它
wo_ai_luo_的博客
10-09 1292
我们先来讲一下这道题的思路，我们输入之后，首先将1~N这N个数字插入到并查集中，然后如果输入的是‘D’，那么就unionSet进行合并（一个集合内的所有元素代表这些犯罪团伙都不是一个团伙），如果输入的是‘A’，那么进行find函数查找a和b的所在集合，我们就只需要判断他们的所在集合是否相同即可。 如果不相同，代表不确定，输出Not sure yet.，如果a和b的父节点是相同的（代表他们是否是同一个集合），如果相同，就输出In the same gang.，如果不是就输出In different
练习它，抓住它，拥有它，成就自己
weixin_34233679的博客
12-10 71
1.帮助他人成功 社交的本质就是不断用各种形式帮助其他人成功； 共享出你的知识与资源、时间与精力、朋友与关系、同情与关爱、从而持续的为他人提供价值，同时提高自己的价值； 2.努力让自己的付出多于回报 因为你会为别人提供价值，别人才会联系你。所以多考虑别人而不是自己； 3.不要保留 不要以为友谊是有限的。这是投资，会越滚越多。 4.成功的关键是...
Onenjudge 百炼 1703 ---- 发现它，抓住它 （并查集的应用）
pku_Coder的博客
12-01 5092
发现它，抓住它 一个城市中有两个犯罪团伙A和B，你需要帮助警察判断任意两起案件是否是同一个犯罪团伙所为，警察所获得的信息是有限的。假设现在有N起案件（N<=100000），编号为1到N，每起案件由团伙A或团伙B所为。你将按时间顺序获得M条信息（M<=100000），这些信息分为两类： 1、 D [a] [b] 其中[a]和[b]表示两起案件的编号，这条信息表明它们属于不同的团伙所为2、A [a] [b]
POJ 百炼 保研机试 4015:邮箱验证
u013240812的专栏
11-10 1040
4015:邮箱验证 查看提交统计提示提问 总时间限制: 1000ms 内存限制: 65536kB 描述POJ 注册的时候需要用户输入邮箱，验证邮箱的规则包括： 1)有且仅有一个'@'符号 2)'@'和'.'不能出现在字符串的首和尾 3)'@'之后至少要有一个'.'，并且'@'不能和'.'直接相连 满足以上3条的字符串为合法邮箱，否则不合法， 编写程序
poj1703 Find them, Catch them
null
04-07 1998
这是题目： 3:Find them, Catch them 查看 提交 统计 提问 总时间限制: 1000ms 内存限制: 65536kB 描述 The police office in Tadu City decides to say ends to the chaos, as launch actions to root up the TWO gangs in the city, G
抓住它
02-13
gRabit-在线市场 该项目包含基本的Rails应用程序框架。 该文件包含此Web应用程序运行所需的说明。 入门 克隆此存储库并创建工作目录后，您可以执行以下步骤来设置和运行该应用程序。 cd进入项目工作目录。...
H5游戏源码 抓住它.zip
10-15
《抓住它》是一款基于H5技术开发的游戏源码，它为开发者提供了深入理解HTML5游戏开发的宝贵资源。H5游戏源码是使用HTML、CSS3和JavaScript等Web技术构建的，可在各种设备上的浏览器中运行，无需安装，即点即玩。这款...
pokemon_yeet：一定要抓住一切
03-03
今天我们要探讨的是一个名为"pokemon_yeet"的项目，它是一个基于Python语言的命令行界面（CLI）宠物小精灵游戏。通过这个项目，我们可以深入了解Python编程在游戏设计中的应用，以及如何通过简单的命令行实现互动...
掌握隐喻：它抓住了我们，但我们能接受它吗？-研究论文
06-09
在这个分析中发现的隐喻的结构属性对应于在有关思想、谈话和行动的交叉点的概念隐喻研究中发现的那些。 从研究的角度来看，这些发现，再加上这种经过验证的方法，可以帮助将隐喻研究放在一个更可靠的基础上解决冲突...
gtl:抓住 Tokilearning
06-07
抓住 Tokilearning 用于在抓取已接受提交的源代码的脚本。 用法 登录 打开开发者控制台（Firefox 中为 CTRL+SHIFT+K，chrome 中为 CTRL+SHIFT+J）并复制以下脚本： c = document . cookie . split ( '; ' ) ; k...
图论---匈牙利算法求二分图最大匹配的实现
m0_61679138的博客
07-09 379
求解二分图最大匹配问题的算法，寻找一个边的子集，使得每个左部点都与右部点相连，并且没有两条边共享相同的端点。使用深度优先搜索来寻找增广路径。当找到一条增广路径时，将路径上的边加入匹配集合中，并更新匹配状态。重复这个过程直到无法找到增广路径为止。
图论基础概念（详细讲解)
禁止抄袭！！！版权所有，抄袭者会举报（禁止转载）。
07-12 199
图的基础概念
图论---哈密顿回路的实现
m0_61679138的博客
07-08 898
在寻找哈密顿回路的过程中，使用深度优先搜索的方法。会遍历所有可能的路径，直到找到一个哈密顿回路或者遍历完所有的路径。在完全图中，可能的路径数量是n的阶乘（n!），因为每个顶点都可以是路径的起点。
2024西安铁一中集训DAY2 ---- 模拟赛（最小生成树 + AC自动机 + 模拟 + rmq）
最新发布
weixin_55851276的博客
07-12 524
因此不用考虑更新它的答案的情况。
网络营销策划方案.docx
07-06
这份网络营销策划方案是一个综合性的工具，它涵盖了市场研究、战略设计、执行计划和资源分配，帮助企业抓住互联网时代的商业机遇，提升品牌形象，扩大市场份额。通过深入分析和精心策划，企业能够更好地适应网络环境...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值