Dwarves

最新推荐文章于 2024-03-14 11:31:00 发布

Nowara_Shinnosuke

最新推荐文章于 2024-03-14 11:31:00 发布

阅读量642

点赞数

分类专栏： hash

本文链接：https://blog.csdn.net/Nowara_Shinnosuke/article/details/76508594

版权

hash 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Problem description

Once upon a time, there arose a huge discussion among the dwarves in Dwarfland. The government wanted to introduce an identity card for all inhabitants.
Most dwarves accept to be small, but they do not like to be measured. Therefore, the government allowed them to substitute the field “height” in their personal identity card with a field “relative dwarf size”. For producing the ID cards, the dwarves were being interviewed about their relative sizes. For some reason, the government suspects that at least one of the interviewed dwarves must have lied.
Can you help find out if the provided information proves the existence of at least one lying dwarf?

Input

The input consists of: one line with an integer n (1 n 10⁵), where n is the number of statements; n lines describing the relations between the dwarves. Each relation is described by:
? one line with “s₁ < s₂” or “s₁ > s₂”, telling whether dwarf s₁ is smaller or taller than dwarf s₂. s₁ and s₂ are two different dwarf names.
A dwarf name consists of at most 20 letters from “A” to “Z” and “a” to “z”. A dwarf name does not contain spaces. The number of dwarves does not exceed 10⁴.

Output

Output “impossible” if the statements are not consistent, otherwise output “possible”.

Sample Input

Sample Input 1

3
Dori > Balin
Balin > Kili
Dori < Kili


Sample Input 2 

3
Dori > Balin
Balin > Kili
Dori > Kili

Sample Output

Sample Output 1

impossible

Sample Output 2

possible

Problem Source

GCPC 2016

题意：给定一些字符串S1,S2...Sn,以及它们之间的大小关系，判断关系是否合理.

举个栗子：
S1<S2,S2<S3,S1<S3 possible
S1<S2,S2<S3,S1>S3 impossible

题解：先不考虑字符串，把它们全部看成点，大小关系看成有向边，题目就可以转换成一张图

eg1无环，eg2有环
解题的关键就是判断是否存在环,
可以通过dfs()求拓扑排序
(紫书168页的代码可以直接贴)

但这题的重点是hash字符串。。。

每个字符串不超过20个字母组成，并且字母由(a~z,A~z)组成
每个字母会有52种可能,可以将字符串看成52进制的数，转成十进制
进制转换：
字符串“1010”
2->10:
1*2^3+0*2^2+1*2^1+0*2^0
52->10:
1*52^3+0*52^2+1*52^1+0*52^0

hash之后就会得到一个很大很大的数用unsigned long long保存(一定会爆，但对这题没啥影响)
然后每个字符串就会得到一个唯一对应的值，因为要保存数据，让它能被塞进数组的下标，这个值要对一个较大的质数取模，模值相对于hash值来说太小，取模之后就可能出现重复的情况，所以要通过链表保存取模后值相同的字符串id.

#include<iostream>
#include<stdio.h>
#include<vector>
#include<string.h>
using namespace std;
typedef unsigned long long ull;
const int maxn=11111;
struct node{
    ull key;
    int id,next;
}buf[maxn];
int n,c[maxn],h[maxn],cnt;
vector<int> e[maxn];
char aa[30],bb[2],cc[30];
bool vis[maxn];
ull gethash(char s[]){
    int len=strlen(s);
    ull ret=0;
    for(int i=0;i<len;i++){
        ret*=52;
        if(s[i]>='a'&&s[i]<='z')
           ret+=s[i]-'a';
        else
           ret+=s[i]-'A'+26;
    }
    return ret;
}
int fnd(ull key){
    for(int i=h[key%maxn];i!=-1;i=buf[i].next)
        if(buf[i].key==key) return buf[i].id;
    return 0;
}
int ins(ull key){
    cnt++;
    buf[cnt].id=cnt,buf[cnt].key=key,buf[cnt].next=h[key%maxn];
    h[key%maxn]=cnt;
    return cnt;
}
bool dfs(int u){
     c[u]=-1;
     for(int i=0;i<e[u].size();i++){
         int v=e[u][i];
         if(c[v]<0) return false;
         else if(!c[v]&&!dfs(v)) return false;
     }
     c[u]=1;
     return true;
}
bool toposort(){
     for(int u=1;u<=cnt;u++)if(!c[u])
         if(!dfs(u)) return false;
     return true;
}
int main(){
    scanf("%d",&n);
    memset(h,-1,sizeof(h));
    for(int i=0;i<n;i++){
        scanf("%s%s%s",aa,bb,cc);
        ull x=gethash(aa);
        ull y=gethash(cc);
        int idx=fnd(x),idy=fnd(y);
        if(!idx) idx=ins(x);
        if(!idy) idy=ins(y);
        if(bb[0]=='<') e[idx].push_back(idy);
        else           e[idy].push_back(idx);
    }
    if(toposort()) printf("possible\n");
    else           printf("impossible\n");
}