2020级数据结构荣誉课第一次上机考试题解(线性表)
目录
题目一:7-1 重复计数 (100 分)
输入格式:
第1行,1个整数N,表示整数的个数,(1≤N≤50000)。
第2行,N个正整数,每个整数x 都满足 1 ≤ x ≤2000000000。
输出格式:
若干行,每行两个用一个空格隔开的数,第一个是数列中出现的数,第二个是该数在序列中出现的次数。
输入样例:
在这里给出一组输入。例如:
12
8 2 8 2 2 11 1 1 8 1 13 13
输出样例:
在这里给出相应的输出。例如:
8 3
2 3
11 1
1 3
13 2
题目解析:
题目让我们统计每个数出现的个数,然后按照数字在序列中第一次出现的位置顺序输出该数及其次数。
方法一:
因此我们很容易的想到用一个long long int 数组 a[n] 来记录一个数n出现的次数,再用另外一个数组q[j]存储数组 a[n] 的下标,来记录该数出现的顺序,并用一个变量 cnt 来记录 q[j] 的数量。
由此,我们新加入一个数 t 时,可以先在 q[j] 中查找,若 t 在数组 q[j] 中出现过,则让 cnt++ , 否则a[q[j]]++。
最后输出时,按照a[q[j]] 的顺序输出即可。
效率分析方面,空间复杂度为O(n),时间复杂度为O(),(参考插入排序),但此O(n)的时间复杂度与不加q[j]的数据相比有大量的剪枝,故效率相对较高。
方法一代码
#include <iostream>
using namespace std;
int main()
{
long long int n;
int q[50000] = {0};
long long int a[50000] = {0};
int cnt = 0;
int t,f = 0;
cin>>n;
for (int i = 0;i<n;i++)
{
cin>>t;
f = 0;
for (int j = 0;j<cnt;j++)
{
if (q[j] == t)
{
a[q[j]]++;
f = 1;
break;
}
}
if (!f)
{
q[cnt] = t;
a[q[cnt++]] = 1;
}
}
cout<<q[0]<<' '<<a[q[0]];
for (int i = 1;i<cnt;i++)
{
cout<<'\n'<<q[i]<<' '<<a[q[i]];
}
return 0;
}
题目二:7-2 报数游戏 (100 分)
题目描述:
n个人围成一圈,从1开始依次编号,做报数游戏。 现指定从第1个人开始报数,报数到第m个人时,该人出圈,然后从其下一个人重新开始报数,仍是报数到第m个人出圈,如此重复下去,直到所有人都出圈。总人数不足m时将循环报数。请输出所有人出圈的顺序。
输入格式:
一行,两个整数n和m。n表示游戏的人数,m表示报数出圈的数字,1≤n≤50000,1≤m≤100.
输出格式:
一行,n个用空格分隔的整数,表示所有人出圈的顺序
输入样例:
在这里给出一组输入。例如:
5 2
输出样例:
在这里给出相应的输出。例如:
2 4 1 5 3
题目分析:
此题为约瑟夫问题,采取数组计数方法,时间复杂度为0(n*m),若采用链表的方法,时间复杂度也是0(n*m)。
我们先看链表的方法,每次循环m次就删除一个链节并输出,直到链表为自环为止。
代码:
#include <iostream>
using namespace std;
typedef struct LINK
{
int n;
struct LINK *next;
}link;
int main()
{
int n,m,m0;
cin>>n>>m;
m0 = m;
link*p,*p1,*p0;
p = new link;
p->n = 1;
p0 = p;
for (int i = 2;i<=n;i++)
{
p1 = new link;
p0->next = p1;
p1->n = i;
p0 = p1;
}
p1->next = p;
p0 = p = p1;
p1 = p1->next;
while (p0->next!=p0)
{
m = m0;
while (--m)
{
p0 = p0->next;
p1 = p1->next;
}
p0->next = p1->next;
cout<<p1->n<<' ';
delete p1;
p1 = p0->next;
}
cout<<p0->n;
return 0;
}
题目三:算术表达式计算 (100 分)
题目描述:
任务: 计算算术表达式的值。
算术表达式按中缀给出,以=号结束,包括+,-,,/四种运算和(、)分隔符。运算数的范围是非负整数,没有正负符号,小于等于109 。
计算过程中,如果出现除数为0的情况,表达式的结果为”NaN” ; 如果中间结果超出32位有符号整型范围,仍按整型计算,不必特殊处理。 输入保证表达式正确。
输入格式:
一行,包括1个算术表达式。算术表达式的长度小于等于1000。
输出格式:
一行,算术表达式的值 。
输入样例:
在这里给出一组输入。例如:
(1+30)/3=
输出样例:
在这里给出相应的输出。例如:
10
题目分析:
此题为表达式计算问题,需要考虑到的问题有优先级问题,字符串处理问题。
数据结构:
两个栈,一个保存符号,一个保存数字 字符串
符号优先级比较方面:
int prior(char ch)
{
if (ch == '+'||ch == '-')
return 1;
else if (ch == '*'||ch == '/')
return 2;
else if (ch == '^')
return 3;
else if (ch == '('||ch == ')')
return 0;
else return -1;
}
遇见符号需要分几种情况:
0.当前符号栈空,当前符号直接入栈。
1.当前符号优先级小于栈顶符号优先级,需要先把栈顶符号计算出来。
2.当前符号优先级大于栈顶符号优先级,当前符号直接入栈。
3.遇见左括号,直接入栈。
4.遇见右括号,符号符号弹栈至左括号。
string first,mid;
cin>>mid;
for (int i = 0;i<int(mid.size())-1;i++)
{
if (mid[i]>='0'&&mid[i]<='9')
{
first += mid[i];
}
else if (mid[i] == '(')
{
st.push(mid[i]);
}
else if (mid[i] == ')')
{
first += '.';
while (st.top()!='(')
{
first += st.top();
st.pop();
}
st.pop();
}
else
{
first += '.';
while (!st.empty() && prior(st.top()) >= prior(mid[i]))
{
first += st.top();
st.pop();
}
st.push(mid[i]);
}
}
符号计算方式为弹出一个符号,弹出两个数,然后进行计算(排除非法计算,如除数为0)
代码:
#include <iostream>
#include <stack>
#include <vector>
#include <math.h>
using namespace std;
stack<char>st;
vector<int>a;
int prior(char ch)
{
if (ch == '+'||ch == '-')
return 1;
else if (ch == '*'||ch == '/')
return 2;
else if (ch == '^')
return 3;
else if (ch == '('||ch == ')')
return 0;
else return -1;
}
int main()
{
string first,mid;
cin>>mid;
for (int i = 0;i<int(mid.size())-1;i++)
{
if (mid[i]>='0'&&mid[i]<='9')
{
first += mid[i];
}
else if (mid[i] == '(')
{
st.push(mid[i]);
}
else if (mid[i] == ')')
{
first += '.';
while (st.top()!='(')
{
first += st.top();
st.pop();
}
st.pop();
}
else
{
first += '.';
while (!st.empty() && prior(st.top()) >= prior(mid[i]))
{
first += st.top();
st.pop();
}
st.push(mid[i]);
}
}
first += '.';
while (!st.empty())
{
first += st.top();
st.pop();
}
int n = -1;
char ch;
int x,y;
for (int i = 0;i<int(first.size());i++)
{
ch = first[i];
if (ch>='0'&&ch<='9')
{
if (n == -1) n = 0;
n = n*10+ch-'0';
}
else if (ch == '.')
{
if (n != -1)
{
a.push_back(n);
n = -1;
}
}
else
{
x = a.back();
a.pop_back();
y = a.back();
a.pop_back();
if (ch == '+')
{
a.push_back(x+y);
}
else if (ch == '-')
{
a.push_back(y-x);
}
else if (ch == '*')
{
a.push_back(x*y);
}
else if (ch == '/')
{
if (!x)
{
printf("NaN");
return 0;
}
a.push_back(y/x);
}
else if (ch == '^')
{
a.push_back(int(pow(y,x)));
}
}
}
cout<<a[0];
return 0;
}
7-4 最喜爱的序列 (100 分)
题目描述:
小唐这段时间在研究序列。拿来N个整数的序列,他给序列中的每个整数都赋予一个喜爱值。喜爱值也是整数,有正有负,越大表明越喜欢。他想知道,如何从序列中连续取最多m个数,他获得喜爱值最大。1≤N≤500000,1≤m≤N。
输入格式:
第一行是两个整数N,m。分别代表序列中数的个数以及能取的最多个数。
第二行用空格隔开的N个整数,第i个整数Li代表他对第i个数的喜爱值。│Li│≤1000
输出格式:
一行,三个数,表示获得最大喜爱值,及第一个取最大喜爱值的区间。
输入样例:
在这里给出一组输入。例如:
5 2
1 4 5 2 3
输出样例:
在这里给出相应的输出。例如:
9 2 3
题目分析:
在n个数中,选择加和最大的,最大长度为m的区间,n个数中有正有负,所以这区间长度从1到m不等。
方法一:暴力
可以用数组 sum[n] 表示前缀和,在n中枚举从1到m的区间进行计算。
即 P[i]=max{sum[i]-sum[j]}j∈(i,i+m)。
效率分析:
该暴力算法时间复杂度为O(n*m),应考虑时间复杂度更低的算法。
方法二:单调队列
也是用 sum[n] 表示前缀和。
我们可以将上面的方程改为:
P[i]=sum[i]-min{sum[j]},j∈(i-M,i-1)
由此,我们只需确保sum[j]为最小值即可。在单调队列中,我们可以构造单调递增的队列,sum[j]为队首即可。
单调队列的构造:
while (!q.empty()&&s[i]<s[q.front()])
{
q.pop_front();
}
q.push_front(i);
维护:
while (!q.empty()&&i-q.back()>m)
{
q.pop_back();
}
记录:
if (M<s[i] - s[q.back()])
{
l = q.back()+1;
r = i;
M = s[i] - s[q.back()];
}
效率分析:
每个元素最多入栈一次,出栈一次,所以时间复杂度为O(n)
代码:
#include <iostream>
#include <queue>
using namespace std;
deque<int>q;
int main()
{
int l,r;
int M;
int s[500000];
int n,m;
cin>>n>>m;
s[0] = 0;
r = l = 1;
for (int i = 1;i<=n;i++)
{
cin>>s[i];
s[i] += s[i-1];
}
M = s[0];
q.push_front(0);
for (int i = 1;i<=n;i++)
{
while (!q.empty()&&s[i]<s[q.front()])
{
q.pop_front();
}
q.push_front(i);
while (!q.empty()&&i-q.back()>m)
{
q.pop_back();
}
if (M<s[i] - s[q.back()])
{
l = q.back()+1;
r = i;
M = s[i] - s[q.back()];
}
}
cout<<M<<' '<<l<<' '<<r;
return 0;
}