POJ 2513

最新推荐文章于 2018-01-30 17:48:06 发布
最新推荐文章于 2018-01-30 17:48:06 发布
阅读量270 收藏
点赞数
分类专栏： 其他OJ 数据结构-并查集 数据结构-树 文章标签： 并查集 字典树 欧拉路

非常综合的一道题，，去年就该把它A掉！！

转载一下大神的讲解，很赞。


转载请注明出处：優YoU  http://user.qzone.qq.com/289065406/blog/1304742541

 

大致题意：

给定一些木棒，木棒两端都涂上颜色，求是否能将木棒首尾相接，连成一条直线，要求不同木棒相接的一边必须是相同颜色的。

 

解题思路：

可以用图论中欧拉路的知识来解这道题，首先可以把木棒两端看成节点，把木棒看成边，这样相同的颜色就是同一个节点

问题便转化为：

给定一个图，是否存在“一笔画”经过涂中每一点，以及经过每一边一次。

这样就是求图中是否存在欧拉路Euler-Path。

回顾经典的“七桥问题”，相信很多同学马上就明白了什么是 欧拉路 了，这里不多作解释。

 

由图论知识可以知道，无向图存在欧拉路的充要条件为：

①     图是连通的；

②     所有节点的度为偶数，或者有且只有两个度为奇数的节点。

 

其中①图的连通性用程序判断比较麻烦，先放一下。

这里先说说②关于度数的判断方法：

 

Blue

Magenta

Violet

Cyan

Red

节点的度用颜色出现次数来统计，如样例中，蓝色blue出现三次（不管是出度还是入度），那么blue结点的度就为3，同样地，我们也可以通过输入得到其他全部结点的度，于是，我们有：

Blue=3

Red=2

Violet=1

Cyan=2

Magenta=2

 

 

用一个一维数组就能记录了，然后分别 模2，就能判断颜色结点的奇偶性

只要奇度数的结点数的个数 = 1 或 >=3 ，即使①图连通，欧拉路也必不存在

 

但是若 奇度数的结点数的个数 为0或 ==2，那么我们继续进行①图的连通性证明：

 

证明①图的连通性，使用并查集MergeSet是非常高效的方法。

基本方法：

初始化所输入的n个结点为n棵树，那么就有一个n棵树的森林，此时每棵树的有唯一的结点（根），该结点的祖先就是它本身。再通过不断地输入边，得到某两个结点（集合）之间的关系，进而合并这两个结点（集合），那么这两个集合就构成一个新的集合，集合内的所有结点都有一个共同的新祖先，就是这个集合（树）的根。

最后只要枚举任意一个结点，他们都具有相同的祖先，那么就能证明图时连通的了。

 

但是单纯使用并查集是会超时的，因为这样会导致每次寻找某个结点的祖先时，平均都会花费O(n/2)时间，最坏情况，当n==50W时，O(n/2)大概为25ms，那么要确定50W个结点是否有共同祖先时，总费时为50W*25ms ，铁定超，不算了= =

 

因此必须使用并查集时必须压缩路径，前几次搜索某个结点k的祖先时，在不断通过父亲结点寻找祖先结点时，顺便把从k到最终祖先结点S中经过的所有结点的祖先都指向S，那么以后的搜索就能把时间降低到O(1)

 

由于并查集必须利用 数组的下标 与 存储的对象，使用int是比较方便的处理方法，但是题目的“颜色结点”是string，不方便用来使用并查集，即使用map也不行，虽然STL的map是基于hash的基础上，但并不高效，在本题中使用会超时。

 

为此可以使用Trie字典树，得到每个颜色单词对应的int编号id ，可以说利用Trie把string一一映射到int，是本题后续处理的关键所在。关于动态创建字典树的方法去百度，这里不多说，下面只用用一个图简单说明一下用Trie字典树标识第一个颜色单词blue：


 

这个题目涉及了多个基本数据结构和算法，综合性很强，非常有代表性，能够A到这题确实是受益良多。

 

知识考查点：

1、字典树；

2、欧拉路：其中又考察了判断是否为连通图；

3、并查集 及其优化方法（路径压缩）。

 

输出：

POSSIBLE：  奇度数结点个数==0 或 ==2  且  图连通

IMPOSSIBLE：奇度数结点个数==1 或 >=3  或  图不连通

 

PS:注意创建TrieTree链表时，C++不存在NULL，要用 0 替代 NULL

 


#include<stdio.h>
#include<iostream>
#include<math.h>
#include<string.h>
#include<iomanip>
#include<stdlib.h>
#include<ctype.h>
#include<algorithm>
#include<deque>
#include<functional>
#include<iterator>
#include<vector>
#include<list>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<sstream>
#define CPY(A,B)memcpy(A,B,sizeof(A))
typedef long long LL;
typedef long double LD;
typedef unsigned long long uLL;
const int MOD=1e9+7;
const int INF=0x3f3f3f3f;
const LL INFF=0x3f3f3f3f3f3f3f3fLL;
const double EPS=1e-9;
const double OO=1e20;
const double PI=acos (-1.0);
int dx[]= {1,-1,0,0,1,-1,1,-1};
int dy[]= {0,0,1,-1,1,1,-1,-1};
int gcd (const LL &a,const LL &b) {return b==0?a:gcd (b,a%b);}
using namespace std;

const int large=500000;  //25W条棒子，有50W个端点

class TrieTree_Node { //字典树结点
    public:
        bool flag;   //标记到字典树从根到当前结点所构成的字符串是否为一个(颜色)单词
        int id;     //当前颜色(结点)的编号
        TrieTree_Node* next[27];

        TrieTree_Node() { //initial
            flag=false;
            id=0;
            memset (next,0,sizeof (next) ); //0 <-> NULL
        }
} root;  //字典树根节点

int color=0;  //颜色编号指针，最终为颜色总个数

int degree[large+1]= {0};  //第id个结点的总度数
int ancestor[large+1];   //第id个结点祖先


/*寻找x结点的最终祖先*/

int find (int x) {
    if (ancestor[x]!=x)
        ancestor[x]=find (ancestor[x]);  //路径压缩
    return ancestor[x];
}

/*合并a、b两个集合*/

void union_set (int a,int b) {
    int pa=find (a);
    int pb=find (b);
    ancestor[pb]=pa;   //使a的祖先 作为 b的祖先
    return;
}

//利用字典树构造字符串s到编号int的映射

int hash (char *s) {
    TrieTree_Node* p=&root;  //从TrieTree的根节点出发搜索单词(单词不存在则创建)
    int len=0;
    while (s[len]!='\0') {
        int index=s[len++]-'a';  //把小写字母a~z映射到数字的1~26，作为字典树的每一层的索引
        if (!p->next[index]) //当索引不存在时，构建索引
            p->next[index]=new TrieTree_Node;
        p=p->next[index];
    }
    if (p->flag) //颜色单词已存在
        return p->id;  //返回其编号
    else { //否则创建单词
        p->flag=true;
        p->id=++color;
        return p->id;   //返回分配给新颜色的编号
    }
}

int main (void) {
    /*Initial the Merge-Set*/
    for (int k=1; k<=large; k++) //初始化，每个结点作为一个独立集合
        ancestor[k]=k;  //对于只有一个结点x的集合，x的祖先就是它本身
    /*Input*/
    char a[11],b[11];
    while (cin>>a>>b) {
        /*Creat the TrieTree*/
        int i=hash (a);
        int j=hash (b); //得到a、b颜色的编号
        /*Get all nodes' degree*/
        degree[i]++;
        degree[j]++;   //记录a、b颜色出现的次数(总度数)
        /*Creat the Merge-Set*/
        union_set (i,j);
    }
    /*Judge the Euler-Path*/
    int s=find (1); //若图为连通图，则s为所有结点的祖先
    //若图为非连通图，s为所有祖先中的其中一个祖先
    int num=0;  //度数为奇数的结点个数
    for (int i=1; i<=color; i++) {
        if (degree[i]%2==1)
            num++;
        if (num>2) { //度数为奇数的结点数大于3，欧拉路必不存在
            cout<<"Impossible"<<endl;
            return 0;
        }
        if (find (i) !=s) { //存在多个祖先，图为森林，不连通
            cout<<"Impossible"<<endl;
            return 0;
        }
    }
    if (num==1) //度数为奇数的结点数等于1，欧拉路必不存在
        cout<<"Impossible"<<endl;
    else       //度数为奇数的结点数恰好等于2或不存在，存在欧拉路
        cout<<"Possible"<<endl;
    return 0;
}
/**耗时更少的写法**/ 
#include<stdio.h>
#include<iostream>
#include<math.h>
#include<string.h>
#include<iomanip>
#include<stdlib.h>
#include<ctype.h>
#include<algorithm>
#include<deque>
#include<functional>
#include<iterator>
#include<vector>
#include<list>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<sstream>
#define CPY(A,B)memcpy(A,B,sizeof(A))
typedef long long LL;
typedef long double LD;
typedef unsigned long long uLL;
const int MOD=1e9+7;
const int INF=0x3f3f3f3f;
const LL INFF=0x3f3f3f3f3f3f3f3fLL;
const double EPS=1e-9;
const double OO=1e20;
const double PI=acos (-1.0);
int dx[]= {1,-1,0,0,1,-1,1,-1};
int dy[]= {0,0,1,-1,1,1,-1,-1};
int gcd (const LL &a,const LL &b) {return b==0?a:gcd (b,a%b);}
using namespace std;
const int maxn=500500;
int fa[maxn],d[maxn],cnt;
struct Trie {
    int sz,t[maxn][15];
    int jud[maxn];
    Trie() {
        sz=1;
        memset (t[0],-1,sizeof t);
        jud[0]=0;
    }
    void Clear() {
        sz=1;
        memset (t[0],-1,sizeof t);
        jud[0]=0;
    }
    int idx (char c) {
        return c-'a';
    }
    void Insert (char* s,int v) {
        int u=0,len=strlen (s);
        for (int i=0; i<len; ++i) {
            int c=idx (s[i]);
            if (t[u][c]==-1) {
                memset (t[sz],-1,sizeof t[sz]);
                jud[sz]=0;
                t[u][c]=sz++;
            }
            u=t[u][c];
        }
        jud[u]=v;
    }
    int Search (char* s) {
        int u=0,len=strlen (s);
        for (int i=0; i<len; ++i) {
            int c=idx (s[i]);
            if (t[u][c]==-1) {
                return -1;
            }
            u=t[u][c];
        }
        if (jud[u]) {
            return jud[u];
        }
        return -1;
    }
}t;
int Find (int x) {
    return x==fa[x]?x:fa[x]=Find (fa[x]);
}
void Union (int a,int b) {
    int r1=Find (a);
    int r2=Find (b);
    if (r1!=r2) {
        fa[r1]=r2;
    }
}
bool eluer() {
    int sum=0,t=-1;
    for (int i=1; i<cnt; ++i) {
        if (d[i]%2) {sum++;}
    }
    if (sum!=0&&sum!=2) {
        return false;
    }
    for (int i=1; i<cnt; ++i) {
        if (t==-1) {t=Find (i);}
        else if (Find (i) !=Find (t) ) return false;
    }
    return true;
}
int main() {
    char s1[20],s2[20];
    cnt=1;
    for (int i=0; i<maxn; ++i) {
        fa[i]=i;
    }
    t.Clear();
    while (~scanf ("%s %s",s1,s2) ) {
        if (t.Search (s1) ==-1) {
            t.Insert (s1,cnt++);
        }
        int u=t.Search (s1);
        if (t.Search (s2) ==-1) {
            t.Insert (s2,cnt++);
        }
        int v=t.Search (s2);
        Union (u,v);
        d[u]++;
        d[v]++;
    }
    eluer() ?puts ("Possible") :puts ("Impossible");
    return 0;
}


Kim0403
关注
专栏目录
POJ 2513 欧拉通路+并查集+trie树
ClearRiver 's Style
10-13 1863
#include #include using namespace std;const int max_size=500001;char s1[11],s2[11];int p[max_size];int r[max_size];int degree[max_size];int num=1;struct TreeNode{ int id;//the i
POJ2513-Colored Sticks【TrieTree+MergeSet+EulerPath】
07-30
北大POJ2513-Colored Sticks【TrieTree+MergeSet+EulerPath】 解题报告+AC代码
POJ2513-Colored Sticks
ζёСяêτ - 小優YoU
07-30 9108
全解题报告索引目录 -> 【北大ACM – POJ试题分类】 转载请注明出处：http://exp-blog.com ------------------------------------------------------------------------- 大致题意： 给定一些木棒，木棒两端都涂上颜色，求是否能将木棒首尾相接，连成一条直线，要求不同木棒相接的一边必...
poj 2513
weixin_33862993的博客
10-12 79
欧拉回路+并查集（判断图的联通）+Tire树（快速查找字符串，并且记录相应点的度数） Tire树相关知识http://zh.wikipedia.org/wiki/Trie #include <iostream> using namespace std; const int maxc = 26; const int maxn = 500001; struct TrieNode { ...
poj题目分类
02-17
* trie 树：例如 poj2513。 4. 简单搜索： * 深度优先搜索：例如 poj2488、poj3083、poj3009、poj1321、poj2251。 * 广度优先搜索：例如 poj3278、poj1426、poj3126、poj3087、poj3414。 * 简单搜索技巧和剪枝...
POJ分类POJ分类POJ分类POJ分类POJ分类POJ分类POJ分类
05-03
- **例题**：poj2513 - **解释**：Trie树（字典树）是一种用于存储和检索字符串的高效数据结构。 ### 三、动态规划 #### 1. 基本动态规划 - **例题**：poj2488, poj3083, poj3009, poj1321, poj2251 - **解释**：...
poj各种分类
09-21
如Trie树（前缀树）、KMP算法，用于字符串匹配和索引构建，见poj2513和poj1961。 #### 排序 快速排序、归并排序和堆排序等，不仅用于排序，也常用于解决与逆序数相关的问题，如poj2388。 #### 并查集 用于处理集合...
poj-2513
比克大魔王的blog
01-30 224
题意大概是，让你每次输入两个颜色单词，表示这是连成一条木棍的单词（从这可以看出这是一个无向图，因为无前后关系），然后他要求说能否根据这个拼接成一条路线，把所有的木棍都应连接，把木棍看成边，单词看成点，就是要让你把所有的边都连一遍，当然是不重复也不漏的，这恰好是无向图欧拉通路的问题。因此要保证图是连通的，而且奇数点的个数要么是0要么是2. 这里判断图的连通用并查集（压缩路径），即看看最后是不是在同
poj2513
Last Order
06-13 769
#include #include using namespace std; int trie[510000][26],bianhao[510000][26],degree[510000],f[510000],n,r; int insert(char *color) { int i,j,k,l; l=strlen(color); j=0; for(i=0;i<l;i++) { k=c
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值