福州大学算法作业题 - 简单哈希

福州大学算法作业题 - 简单哈希

★实验任务

算法萌新小 A 向算法大佬大 D 请教什么是哈希。为了让小 A 明白,大 D 写 了一些字母和一些单词作为演示,目的是将一个字母映射成一个单词,
可是大 D 的字迹太潦草,小 A 完全看不出每个单词之间的间隔,请你帮助小 A 判断大 D 所写的每个字母和单词之间的映射是否正确(默认全是小写字母,映射关系为双 射)。 

★数据输入

输入一个 T(T<=5),表示样例数 每个样例第一行输入一个字符串 letters,表示映射前的字母 每个样例第二行输入一个字符串 words,表示映射后的单词(单个字母也算单 词) 

★数据输出

输出一个布尔值,表示字母与单词之间的映射是否正确 

★数据范围

80%的得分点,字符串长度均小于 10 其余 20%的得分点,字符串长度小于 20 

代码1:

#include <string>  
#include <vector>  
#include <map>  
#include <iostream>  
using namespace std;  
  
  
bool wordPattern(string pattern, int i, string str, int j, map<string, int>& st, map<char, int>& p) {  
  
  
  if(i == pattern.size() && j == str.size()) return true;  
  
  if(i == pattern.size() || j == str.size()) return false;  
  
  char c = pattern[i];  
  for(int k = 1; k <= str.size() - j; ++k) {  
  
    if(p[c] == st[str.substr(j, k)]) {  
         
        p[c]++;  
  
        st[str.substr(j, k)]++;   
          
      if(wordPattern(pattern, i + 1, str, j + k, st, p)) return true;  
        p[c]--;  
        st[str.substr(j, k)]--;  
      }  
  }  
  return false;  
}  
bool wordPattern(string pattern, string str)   {  
  
 map<string, int> st;  
 map<char, int> p;  
  return wordPattern(pattern, 0, str, 0, st, p);  
}  
   
int main(void) {  
    char t;  
  string p,str;  
 int i,n;  
  cin>>n;  
    for(i=0;i<n;i++)  
    {  
        cin>>p>>str;  
        if(wordPattern(p, str))  
        cout<<"true"<<endl;  
        else  
        cout<<"false"<<endl;  
    }  
    return 0;  
}  

代码2:

#include <string>    
#include <vector>    
#include <map>    
#include <iostream>    
using namespace std;    
    
bool wordPattern(string pattern, int i, string str, int j, map<string, int>& st, map<char, int>& pat) {    
    if(i == pattern.size() && j == str.size()) return true;    
    if(i == pattern.size() || j == str.size()) return false;    
    char c = pattern[i];    
    for(int k = 1;k <= str.size() - j; ++k) {    
        if(pat[c] == st[str.substr(j, k)]) {    
            pat[c]++;    
            st[str.substr(j, k)]++;    
            if(wordPattern(pattern, i + 1, str, j + k, st, pat)) return true;    
            pat[c]--;    
            st[str.substr(j, k)]--;    
      }    
  }    
    return false;    
}    
    
bool wordPattern(string pattern, string str) {      
  map<string, int> st;    
  map<char, int> pat;    
  return wordPattern(pattern, 0, str, 0, st, pat);    
}    
    
    
int main() {    
   int n,i,j;    
   scanf("%d",&n);    
   int s[25];    
   for(i=0;i<n;i++){    
      string a,b;    
      cin>>a>>b;    
      s[i]=wordPattern(a,b);    
   }    
    
   for(j=0;j<n;j++){    
     if(s[j]==1)    
       printf("true\n");    
     else    
       printf("false\n");    
   }    
  return 0;    
}  

代码3:

#include<iostream>  
#include <stdio.h>  
#include<string>  
#include <map>  
#include <vector>  
using namespace std;  
  
bool jdhx(string chars, int p, string words, int r, map<char, string> &m);  
  
int main()  
{  
    string chars[5],words[5]; //定义5组key value  
    int n,i;  
    scanf("%d",&n);  
    for(i=0;i<n;i++)  
    {  
      
        cin>>chars[i];  
        cin>>words[i];  
    }  
      
    map<char, string> m;  
    for(i=0;i<n;i++)  
    {  
        m.clear();  
        bool res = jdhx(chars[i], 0, words[i], 0, m);   
        if (res)  
            printf("true\n");  
        else  
            printf("false\n");  
    }  
}  
  
  
  
  
// map : char -> word  
bool jdhx(string chars, int p, string words, int r, map<char, string> &m)  
{ //chars--字母   words--单词       
  
    if (p == chars.size() && r == words.size())  //如果两个指针都指向了终点 ,匹配成功  
    {  
        return true;  
    }  
    if (p == chars.size() || r == words.size())//若只有其中一个指针指向了终点,匹配失败  
    {  
        return false;  
    }  
    char c = chars[p];  //选出一个 char  
    for (int i = r; i < words.size(); ++i)  //开始遍历,word 的长度每次都+1  
    {  
        string t = words.substr(r, i - r + 1);  // t.length() == i  
        if (m.count(c) && m[c] == t) // char : word 存在 m 中  
        {  
            if (jdhx(chars, p + 1, words, i + 1, m)) // 继续向后递归  
            {  
                return true;  
            }  
        }  
        else if (!m.count(c)) // char 不存在于 m.keys()  
        {  
            bool b = false;  
            map<char, string>::iterator it=m.begin();  
            while(it!=m.end()) // 遍历 m, 检查 word 是否存在于 m.values() 中  
            {  
                if (it->second == t) // word 存在于 m.values() 中  
                {  
                    b = true;  
                    break;  
                }  
                it++;  
            }  
            if (!b) // word 不存于 m.values()  
            {  
                m[c] = t;  // 将 char:word 存入 m  
                if (jdhx(chars, p + 1, words, i + 1, m)) //继续向后递归  
                {  
                    return true;  
                }  
                m.erase(c);  // 递归求解失败, 将 char:word 从 m 中删除  
            }  
        }  
    }  
    return false;  
}  



posted @ 2018-10-28 15:33 BlameKidd 阅读( ...) 评论( ...) 编辑 收藏

猜你喜欢

转载自blog.csdn.net/qq_33555334/article/details/86177201