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;
}
585
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
