记录week15的作业三道题

最新推荐文章于 2024-08-20 15:59:15 发布
最新推荐文章于 2024-08-20 15:59:15 发布
阅读量137 收藏
点赞数
文章标签： hash 数据结构 字符串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43668519/article/details/106549084
版权

A- ZJM 与霍格沃兹 、B-ZJM 与生日礼物 、C-ZJM 与纸条
A:
原题链接
题意就是建立一个字典，格式为：[魔咒] 对应功能，数据量是10 0000条，每条长度最大100。这样的话，我们直接建立map<string,string>会炸掉，需要自己写hash做一个映射。
开始我的思路是：做两个map<int,string>m1,m2，对一个字符串进行取hash，然后查询。但是发现会内存爆掉，然后改用

string a[200010];
map<int,int>mm1,mm2;

来进行建立map，map只存储字符串的下标，就可以过。（map对空间的占用看来是挺大的。

#include<iostream>
#include<map>
#include<string>
const long long int  mod= 1e9+7;
using namespace std;
int gethash(string s){
int sum=0;int seed=17;
	for(int i=0;i<s.length();i++)
	{
		sum=(sum+s[i]*seed)%mod;
		seed=seed*17%mod;
	}
	return sum;
}
string a[200010];
map<int,int>mm1,mm2;
int main()
{
	
    //map<int,string>m1,m2;
    string s;
    int n;int k=0;
    while(getline(cin,s) && s!="@END@")
    {
    	string s1,s2;
        s1=s.substr(1,s.find(']',0)-1);
        s2=s.substr(s.find(']',0)+2); 
        int h1=gethash(s1);int h2=gethash(s2);
        //cout<<s1<<"   //    "<<s2<<endl;
//		m1[h1]=s2;
//        m2[h2]=s1;
        mm1[h1]=++k;
        a[k]=s2;
        mm2[h2]=++k;
        a[k]=s1;
    }
    cin>>n;
    getchar();
    while(n--)
    {
      getline(cin,s);
	  if(s[0]=='[')
	  {
	    string p=s.substr(1,s.find(']',0)-1);
		int t=gethash(p);
	     map<int,int>::iterator it;it=mm1.find(t);
		if(it!=mm1.end())cout<<a[mm1[t]]<<endl;
		else cout<<"what?"<<endl;	
	  }
	  else
	  {
	    string p=s;
		int t=gethash(p); 
		map<int, int>::iterator it;it=mm2.find(t);
		if(it!=mm2.end())cout<<a[mm2[t]]<<endl;	//cout<<"["<<a[mm2[t]]<<"]"<<endl;	
		else cout<<"what?"<<endl;	
	  } 
    }
    return 0;
}

B：
原题链接
字典树……
我数据结构最后的大课设就是做一个字典树，所以对字典树还是很熟悉的，但是也有些不同。
数据结构课设用的字典树我分别采用指针数组做节点和map做节点实现了两种建立在字母上的26元字典树结构。
这次用的是的是采用数组的方式存储树结构，建立在01串上的字典树。具体怎么解就不写了，直接贴一下代码。

这次的代码：

#include<iostream>
#include<string>
#include<string.h>
using namespace std;
struct Trie{
	static const int N=1010,charset =2;
	int tot,root,child[N][charset],flag [N];
    Trie(){
    	memset(child,-1,sizeof(child));root=tot=0;
	}
	void clear(){
		memset(child,-1,sizeof(child));
		memset(flag ,-1,sizeof(flag));
	}
	bool insert(char *str){
	 int now=root,len=strlen(str);
	 bool jud=false;	
	 for(int i=0;i<len;i++){
	 	int x=str[i]-'0';
	 	if(child[now][x]==-1){
	 		child[now][x]=++tot;
	 		flag[now]=0;
		 }
		 else if(i==len-1||flag[child[now][x]])jud=1;
		 now=child[now][x];
	 }
	 flag[now]=1;
	 return jud;
	}
};


int main(){
    Trie A; char str[100];
    bool ans=true;int cnt=0;bool mark=0;
    while(scanf("%s",str)!=EOF)
    {   
        if(str[0]!='9') {
        	bool t=0;t=A.insert(str);
		 if(t==true&&mark==0){
		 	ans=false;mark=1;
		 }
		 else if(mark==0){
		 	ans=true;
		 }
		}
        else
        {
            printf("Set %d %s\n",++cnt,ans?"is immediately decodable":"is not immediately decodable");
             A.clear();
            ans=true;mark=0;
        }
    }


	return 0;
}

数据结构课设 map版本

锘?include<iostream>
#include<fstream>
#include<ctime>
#include<map>
#include<unordered_map>
#include<string>
using namespace std;

//鐢╩ap浣滃搱甯岃〃
class Node
{
public:
	int line;
	bool is_word = false;
	unordered_map<char, Node*> children;
	~Node()
	{
		for (int i = 0; i < 26; ++i)
		{
			if (children.find('a' + i) != children.end()) delete children['a' + i];
		}
	}
	void insert(const string _Word, int line)
	{
		Node* p = this;
		for (int i = 0; i < _Word.size(); ++i)
		{
			char curr = _Word[i];
			if (p->children.find(curr) == p->children.end())
			{
				p->children.insert(map<char, Node*>::value_type{ curr,new Node() });
			}
			p = p->children[curr];
		}
		p->is_word = true;
		p->line = line;
	}
	int has_prefix(const string& _Word)
	{
		Node* p = this;
		int i = 0;
		for (; i < _Word.size(); ++i)
		{
			char curr = _Word[i];
			if (p->children.find(curr) == p->children.end())
			{
				if (p->is_word)return p->line;
				else return -1;
			}
			else
			{
				p = p->children[curr];
			}
		}
		return -1;
	}
};



int main() {
	clock_t startTime, endTime;
	startTime = clock();//璁℃椂寮€濮?


	Node A;
	int line = 1;
	string temp;
	ifstream in("input_1e7.txt");
	while (getline(in, temp))
	{
		A.insert(temp, line);
		line++;
	}

	endTime = clock();//璁℃椂缁撴潫
	cout << "The run time is: " << (double)(endTime - startTime) / CLOCKS_PER_SEC << "s" << endl;
	return 0;
}

指针版本：

#include<bits/stdc++.h>
using namespace std;
queue< pair<char,int> >q;
struct node{
	int line;
	char c;
	node *child[26];
	node(){
		line=-1;
		c='#';
		memset(child,NULL,sizeof(child));
	} 
};
char ch[26];
void ini(){
	for(int i=0;i<26;i++)ch[i]='a'+i;
}


void dfs(node*p){
	if(p->line!=-1)
	q.push(make_pair(p->c,p->line));
	//cout<<p->c<<endl;
	for(int i=0;i<26;i++)
	{
	  if(p->child[i]!=NULL)dfs(p->child[i]);
	} 
}

class trie{
public:
	node*root;
	
public:
   trie(){
   	root=new node;
   }
void insert(string s,int line)
{
	node*p=root;
    for(int i=0;i<s.size()-1;i++)
   	{
   	  	int t=s[i]-'a';
   	  	if(p->child[t]==NULL)p->child[t]=new node,p->child[t]->c=s[i];
   	  	p=p->child[t];
	}
	int t=s[s.size()-1]-'a';
    if(p->child[t]==NULL)p->child[t]=new node,p->child[t]->c=s[s.size()-1];
    p->child[t]->line=line;
}
int exactfind(string s){
   node *p=root;
   for(int i=0;i<s.size();i++)
   {
     int t=s[i]-'a';
     if(p->child[t]!=NULL)
	 p=p->child[t];
	 else {p=NULL;break;}   	
   }
   int re;	
   if(p==NULL)re=-1;else  re=p->line;
   if(re==-1){cout<<"未找到！"<<endl;return -1;}
   else {cout<<"在第"<<re<<"行"<<endl;return 0;}
}
void _delete(string s)
{
   int k=exactfind(s);if(k==-1)return;
   node *p=root;
   for(int i=0;i<s.size();i++)
   {
     int t=s[i]-'a';
	 p=p->child[t];   	
   }
   p->line=-1;	
}
void roughfind(string s)
{
   //	 int k=exactfind(s);if(k==-1)return;
   while(q.size())q.pop();
   node *p=root;
   for(int i=0;i<s.size();i++)
   {
     int t=s[i]-'a';
	 if(p->child[t]!=NULL)
	 p=p->child[t];
	 else {p=NULL;break;}     	
   }
   //cout<<p->c<<"  and "<<p->line<<endl;
   if(p==NULL){cout<<"未找到！"<<endl;return; }
   dfs(p);	
}
void list(){
	while(q.size())
	{
		cout<<"在第"<<q.front().second<<"行"<<endl;
	    q.pop();
	}
}
void meun(){
	cout<<"0:插入 1:精确查找 2:删除 3:部分查找 5:退出"<<endl;
	int op=0;
	string ss;int ll;
	while(1){
		cin>>op;
		if(op==5)break;
		switch (op)
		{
			case 0:
			    cin>>ss>>ll;
			    this->insert(ss,ll);
				break; 
			case 1:
				cin>>ss;
				this->exactfind(ss);
				break;
			case 2:
				cin>>ss; 
				this->_delete(ss);
				break;
			case 3:
				cin>>ss;
				this->roughfind(ss);
				this->list();
				break;
		}
	}
	
}

};



int main(){
clock_t startTime,endTime;
startTime = clock();//计时开始


	ini();
  trie A;
int line=1;
string temp;
ifstream in("input.txt");
while(getline(in,temp))
{
	A.insert(temp,line);
	line++;
}
endTime = clock();//计时结束
cout << "The run time is: " <<(double)(endTime - startTime) / CLOCKS_PER_SEC << "s" << endl;

A.meun();
return 0;	
}

C：
C题是KMP,个人感觉贼难，找一个字符串在另一个字符串中出现的次数。核心思想是建立一个next数组，利用这个next数组进行跳跃式遍历，提高查询效率，降低复杂度。
关于next数组的建立，我的理解是：next[i]存放的是一旦 i 匹配不上，我们该跳到子串的什么位置继续匹配。求next[i]的过程就是找 i 前面字符串的“前缀、后缀最长重合长度”。我们设 i , j 变量分别表示前后缀的最后字符位置，相等，那么都加一，失配，那么 i 回溯到next[i]，用这样一种递推似的思想来求出整个next数组。

#include<iostream>
#include<string>
#include<string.h>
using namespace std;
char ptr[10005];
char str[1000005];
int Next[10005];
void getnext(const char ptr[],int len){
	Next[0]=0;
	for(int i=1,j=0;i<len;++i){
		while(j&&ptr[i]!=ptr[j])j=Next[j-1];
		if(ptr[i]==ptr[j])j++;
		Next[i]=j; 
	}
}
int kmp(const char str[],const char ptr[]){
	int len1=strlen(str);
	int len2=strlen(ptr);
	int cnt=0;
	getnext(ptr,len2);
	for(int i=0,j=0;i<len1;++i){
		while(j&&str[i]!=ptr[j])j=Next[j-1];
		if(str[i]==ptr[j])j++;
		if(j==len2){
			cnt++;
			j=Next[j-1];
		}
	}
	return cnt;
}



int main(){
	int n=0;cin>>n;
	while(n--){
		scanf("%s",ptr);
		scanf("%s",str);
		cout<<kmp(str,ptr)<<endl;
		memset(str,0,sizeof(str));
		memset(ptr,0,sizeof(ptr));
		memset(Next,0,sizeof(Next));
	}
	return 0;
}
↝↝
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Coursera-Deep-Learning-Andrew-Ng:《深度学习》专项课程 之 记录自己学习过程中的笔记、编程作业
04-14
详细完整版（选择题代码+相关附件下载+文字解释）**请参照：项目目录课程周数名称类型地址课程1 - 神经网络和深度学习Week 1深度学习概论————无编程作业————Week 2神经网络基础Note具有神经网络思维的...
Oracle 练习题 很好的自测题
05-31
### Oracle练习题知识点详解 #### 一、Oracle基础练习题解析 ##### CORE-E-001：基础SQL操作与理解 1. **SQLPLUS连接失败（ORA-12541）** - **问题**: 当尝试使用SQL*Plus工具连接Oracle数据库时，可能会遇到...
记录week13的作业后三道题
qq_43668519的博客
05-21 152
作业： C题： 免费套餐： 题目类似一座树塔，在0-10范围内，某一秒会在若干个位置有馅饼，然后我们要求能接住的最多的馅饼。 首先我们构建一个二维数组，存储某个时间，某个位置的馅饼数目。**dp[t][x]**表示在t时刻，x位置有dp[t][x]个馅饼。 然后总结状态方程： dp[t][x]=max(dp[t-1][x],dp[t-1][x-1],dp[t-1][x+1])+dp[t][x] 然后在写的时候发现：他不对,因为你初始时在5位置，从t=1开始，无法判断他的来源是否合法,也就是可能会出现t=1时
记录week7的实验一道题+作业三道题
qq_43668519的博客
04-05 197
路径解析、TT 的魔法猫、TT 的旅行日记、TT 的美梦 作业: TT 的魔法猫： 这道题是用的Floyd算法解决，因为胜负具有传递性，所以是一个传递闭包问题。目的是求有多少个场胜负无法预测，于是将插点求最短路的判断改为插电求&运算。即 map[i,j] = Max { map[i,k]&map[k,j] , map[i,j] }； Floyd算法空间复杂度O(n^2)。时间时...
记录week14的实验一道题+作业三道题
qq_43668519的博客
05-25 265
作业： C： Q老师的考验 Q老师 对数列有一种非同一般的热爱，尤其是优美的斐波那契数列。 这一天，Q老师 为了增强大家对于斐波那契数列的理解，决定在斐波那契的基础上创建一个新的数列 f(x) 来考一考大家。数列 f(x) 定义如下： 当 x < 10 时，f(x) = x； 当 x ≥ 10 时，f(x) = a0 * f(x-1) + a1 * f(x-2) + a2* f(x-3) + …… + a9 * f(x-10)，ai 只能为 0 或 1。 Q老师 将给定 a0～a9，以及两个正整数
记录week9的实验一道题+作业三道题
qq_43668519的博客
04-25 140
咕咕东的目录管理器、东东学打牌 、签到题、炉石传说 作业： 咕咕东的目录管理器： 原题链接 题意大概就是模拟一个类似linux的目录管理器，并且模拟题目里所给出的操作。这是一道复杂的模拟题，整道题很难找到头绪，经过课上的讲解，我们运用面向对象的思路去解题。 构建命令结构和目录结构，用树的方式描述目录，以map存储孩子。 题目的难点主要在tree操作，在这一步需要对树进行输出，由于题目的数据范围很大...
记录week8的实验三道题+作业三道题
qq_43668519的博客
04-17 275
区间选点、猫猫向前冲、班长竞选、HRZ 的序列、HRZ 学英语、咕咕东的奇妙序列 作业: 区间选点： 还是那道熟悉的区间选点，可是跟原来的题意不一样了，现在是每个区间要求的点数不同，并且要求用差分约束系统的解法解决这道题。 这道题我觉得难就难在你怎么把他构建成图，用差分这个想法太奇特了，很不容易想到。但是题目既然已经讲了也就难度降低了。 思路大概就是：以s[i]表示i点之前有多少个点。然后某个区...
记录week12的实验三道题+作业五道题
qq_43668519的博客
05-12 256
sverer 作业： A： 这道题很简单，不在赘述 代码： #include <iostream> using namespace std; int main() { int n,i,m,t,ans; while(cin>>n) { int a[32768]= {0}; t=(n+1)/2; for(i=0; i<n; i++) { cin>>m;
记录week10的实验两道题+作业三道题
qq_43668519的博客
04-25 206
签到题、LIS & LCS、 拿数问题 II、签到题、东东转魔方 作业： 签到题： 题意： 在一开始他有一个数字n，他的目标是把它转换成m，在每一步操作中，他可以将n乘以2或乘以3，他可以进行任意次操作。输出将n转换成m的操作次数，如果转换不了输出-1。 思路是：将m除以n，判断是否能整除，若能则继续除以三，不能就除以二，直到最后，如果能除尽了就ok（要用longlong #inclu...
记录week11的作业六道题
qq_43668519的博客
05-02 131
1、2、3、4、东东与 ATM、东东开车了 作业： 1、2、3： 前四道题难度比较低，这三道也没什么特别的技巧，第一道题就是算数然后比较，float类型即可。第二道题是旋转矩阵，还是方阵，这就降低了难度，只需要写一个旋转九十度的函数即可，主要就是一个公式：t1[i][j]=A[n-j-1][i];第三道题是密码的转换，getline读入后对ASCII码进行操作即可。 #include<bit...
Week15作业-必做题
FEIXIANGDEXINZHE的博客
06-03 148
A - ZJM 与霍格沃兹 ZJM 为了准备霍格沃兹的期末考试，决心背魔咒词典，一举拿下咒语翻译题 。题库格式：[魔咒] 对应功能 背完题库后，ZJM 开始刷题，现共有 N 道题，每道题给出一个字符串，可能是 [魔咒]，也可能是对应功能 ZJM 需要识别这个题目给出的是 [魔咒] 还是对应功能，并写出转换的结果，如果在魔咒词典里找不到，输出 “what?” Input 首先列出魔咒词典中不超过100000条不同的咒语，每条格式为： [魔咒] 对应功能 其中“魔咒”和“对应功能”分别为长度不超过20和80
高中英语翻译题.docx
09-29
#### 三、翻译题详解与分析（续） ##### 1. 为了按时完成这项任务，他们夜以继日的工作着。 **原文:** To finish the task on time, they work day and night. **解析:** “To finish the task on time”为了按时...
leetcode题库-algorithm-train-001:算法训练-001
06-29
文档，你可以将自己当周的学习心得以及做题过程中的思考记录在该文档中（该项不属于作业内容，是可选项）。 作业提交规则 算法题作业的提交 先将本仓库 fork 到自己的 GitHub 账号下。 将 fork 后的仓库 clone 到...
Week12_Unit11_RSYNC文件同步服务.pdf
05-16
- 至少完成两道实验题，并且提交含有学号和姓名缩写的截图。 - 修改提交作业的文件名和系统主机名。 - 完成学习情况交流问卷。 #### 学习目标与理论依据 - 掌握RSYNC文件同步原理。 - 实现本地和远程文件同步。 - ...
数据结构----栈
新手嵌入式学习的博客
08-19 953
数据结构顺序栈和链式栈。
集合及数据结构第三节————包装类和简单认识泛型
2301_79418684的博客
08-19 1149
包装类和简单认识泛型 1. 基本数据类型和对应的包装类 2. 装箱和拆箱 3. 泛型 4. 泛型类的使用 5. 裸类型(Raw Type) （了解） 6. 泛型如何编译的 7. 泛型的上界 8. 泛型方法
【数据结构-距离合】力扣1685. 有序数组中差绝对值之和
最新发布
sjsjs11的博客
08-20 320
换句话说， result[i] 等于 sum(|nums[i]-nums[j]|) ，其中 0 <= j < nums.length 且 j!请你建立并返回一个整数数组 result，它跟 nums 长度相同，且result[i] 等于 nums[i] 与数组中所有其他元素差的绝对值之和。，可以得到每个元素和其他元素的绝对值之和与该元素以及左边元素和及右边元素和之间的关系，进行计算即可。输入：nums = [1,4,6,8,10]输出：[24,15,13,15,21]输入：nums = [2,3,5]
数据结构（邓俊辉）学习笔记】优先级队列 06——完全二叉堆：批量建堆
weixin_44399845的博客
08-18 874
完全二叉堆：批量建堆
SAS BASE考试攻略：70道真题解析
"SAS BASE 考试复习资料，包含70道真题，适用于短期高效备考，确保通过。" SAS（Statistical Analysis System）是广泛应用的数据分析和统计软件，其基础模块（BASE SAS）提供了数据管理、数据转换、数据分析和报告...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值