JLU数据结构第二次上机实验

Posted 2021-06-08 荒于曦

JLU数据结构第二次上机实验

数列查询

Code Size Limit 16 KB
Time Limit 10 ms
Memory Limit 1 MB

题目描述

已知数列的通项公式为:

     f(n) = f(n-1)*11/10，f[1]=10. 

通项从左向右计算，*和/分别表示整数乘法和除法。 现在，要多次查询数列项的值。

输入格式

第1行，1个整数q，表示查询的次数， 1≤q≤10000. 第2至q+1行，每行1个整数i，表示要查询f(i)的值。

输出格式

q行，每行1个整数，表示f(i)的值。查询的值都在32位整数范围内。

输入样例

在这里给出一组输入。例如：

3
1
2
3

输出样例

在这里给出一组输出。例如：

10
11
12

思路

因为要查询多次，如果每次都重新计算非常耗时。可以先计算出第1项到第max项并记录下来，max设置为多少合适呢，当然是输入中最大的那个项数。

代码

#include<iostream>
using namespace std;
int main(){
    int N;
    scanf("%d",&N);
    int ai[N];
    int Max=0;
    for(int i=0;i<N;i++){
        scanf("%d",&ai[i]);
        if(ai[i]>Max)Max=ai[i];
    }

    int a[Max];
    a[0]=10;
    for(int i=0;i<Max;i++){
        a[i+1]=a[i]+a[i]/10;
    }

    for(int i=0;i<N;i++){
        printf("%d\\n",a[ai[i]-1]);
    }
    //f(n) = f(n-1)*11/10，f[1]=10;
    return 0;
}

稀疏矩阵之和

Code Size Limit 16 KB
Time Limit 100 ms
Memory Limit 10 MB

---

题目描述

矩阵A和B都是稀疏矩阵。请计算矩阵的和A+B.如果A、B不能做和，输出“Illegal！”

输入格式

矩阵的输入采用三元组表示，先A后B。对每个矩阵：

第1行，3个整数N、M、t，用空格分隔，分别表示矩阵的行数、列数和非0数据项数，10≤N、M≤50000，t≤min(N,M).

第2至t+1行，每行3个整数r、c、v，用空格分隔，表示矩阵r行c列的位置是非0数据项v, v在32位有符号整型范围内。三元组默认按行列排序。

输出格式

矩阵A+B，采用三元组表示，默认按行列排序，非零项也在32位有符号整型范围内。

输入样例

10 10 3
2 2 2
5 5 5
10 10 20
10 10 2
2 2 1
6 6 6

输出样例

10 10 4
2 2 3
5 5 5
6 6 6
10 10 20

思路

这题思路上没什么特别复杂的。也不列代码了（原来做这题的时候刚学 类，然后就想着用类封装矩阵，结果搞得很复杂，虽然还是通过了，但大家不要学习。）

复习一下三元组（参考此题题目）。适用于稀疏矩阵，只记录矩阵中有值的元素Aij，Aij的行数i，列数j和它的大小构成一个三元组（i，j，v）。一个矩阵就是一个顺序表，储存很多这样的三元组，记录了矩阵中所有有值的元素。

文字编辑

Code Size Limit 16 KB
Time Limit 1000 ms
Memory Limit 2 MB

---

题目描述

一篇文章由n个汉字构成，汉字从前到后依次编号为1，2，……，n。 有四种操作：

A i j表示把编号为i的汉字移动编号为j的汉字之前；

B i j表示把编号为i的汉字移动编号为j的汉字之后；

Q 0 i为询问编号为i的汉字之前的汉字的编号；

Q 1 i为询问编号为i的汉字之后的汉字的编号。

规定：1号汉字之前是n号汉字，n号汉字之后是1号汉字。

输入格式

第1行，1个整数T，表示有T组测试数据， 1≤T≤9999.

随后的每一组测试数据中，第1行两个整数n和m，用空格分隔，分别代表汉字数和操作数，2≤n≤9999，1≤m≤9999；第2至m+1行，每行包含3个常量s、i和j，用空格分隔，s代表操作的类型，若s为A或B，则i和j表示汉字的编号，若s为Q，i代表0或1，j代表汉字的编号。

输出格式

若干行，每行1个整数，对应每个询问的结果汉字编号。

输入样例

在这里给出一组输入。例如：

1 
9999 4 
B 1 2  
A 3 9999
Q 1 1
Q 0 3

输出样例

在这里给出一组输出。例如：

4
9998

思路

双向链表。

这道题加深了我对链表的理解：增删改只需改变指针的指向，无需移动数据本身。如果数据按编号顺序存放于数组（数据放在a[i]位置相当于编号为 i ），在一系列增删改的操作后，查询的方式依然不变，通过编号查询到的数据依然是原来的数据，这使查询的代价保持在O（1）。

代码

#include<iostream>
#include<stack>
#include<string.h>
using namespace  std;
static int begin=0;
struct data{
    data*last;
    data*next;
};
void doOperate(data*a){
    char opk;
    int i,j;
    scanf(" %c %d %d",&opk,&i,&j);
    data*p1,*p2;
    if(opk==\'A\'){//i到j前
        p1=a[i].last;
        p2=a[i].next;
        p1->next=p2;
        p2->last=p1;

        p1=a[j].last;
        p2=&a[j];
        p1->next=&a[i];
        a[i].last=p1;
        p2->last=&a[i];
        a[i].next=p2;
    }else if(opk==\'B\'){
        p1=a[i].last;
        p2=a[i].next;
        p1->next=p2;
        p2->last=p1;

        p1=&a[j];
        p2=a[j].next;
        p1->next=&a[i];
        a[i].last=p1;
        p2->last=&a[i];
        a[i].next=p2;
    }else if(opk==\'Q\'){
        if(::begin){
            printf("\\n");
        }else ::begin=1;
        if(i==0){
            printf("%d",a[j].last-a);
        }else if(i==1){
            printf("%d",a[j].next-a);
        }
    }
    return;
}
void doTest(){
    int nw,nop;
    scanf(" %d %d",&nw,&nop);
    data ad[nw+1];
    for(int i=1;i<=nw;i++){
        if(i!=1)ad[i].last=&ad[i-1];
        else ad[i].last=&ad[nw];
        if(i!=nw)ad[i].next=&ad[i+1];
        else ad[i].next=&ad[1];
    }
    for(int i=0;i<nop;i++){
        doOperate(ad);
    }
    return;
}
int main(){
    int T;
    scanf("%d",&T);
    for(int i=0;i<T;i++){
        doTest();
    }
    return 0;
}

幸福指数

Code Size Limit 16 KB
Time Limit 100 ms
Memory Limit 64 MB

---

题目描述

人生中哪段时间最幸福?幸福指数可能会帮你发现。幸福指数要求：对自己每天的生活赋予一个幸福值，幸福值越大表示越幸福。一段时间的幸福指数就是：这段时间的幸福值的和乘以这段时间的幸福值的最小值。幸福指数最大的那段时间，可能就是人生中最幸福的时光。

输入格式

第1行，1个整数n，， 1≤n≤100000,表示要考察的天数。

第2行，n个整数Hi，用空格分隔，Hi表示第i天的幸福值，0≤n≤1000000。

输出格式

第1行，1个整数，表示最大幸福指数。

第2行，2个整数l和r，用空格分隔，表示最大幸福指数对应的区间[l,r]。如果有多个这样的区间，输出最长最左区间。

输入样例

在这里给出一组输入。例如：

7
6 4 5 1 4 5 6

输出样例

在这里给出一组输出。例如：

60
1 3

思路

单调递增栈。

思考铺垫：这道题可以类比求最大矩形面积，第 i 天（幸福值为hi）相当于高和宽都为hi的矩形。将所有的矩形按天数顺序排成一行，形成一个一维坐标轴，每个矩形的左右边界都对应坐标轴上一点。将第 i 天幸福值 hi 视为目标区间中最小的幸福值，向两边分别找到比 i 还矮的矩形，这个位置就是边界，两端边界的距离*hi就是关于 i 的最大矩形。

正式做法：维护一个单调递增栈，依次读入幸福值 hi ，如果hi>top，就入栈，而且这相当于原来top的右边界拓展了；如果hi<top，就让top出栈，继续比较，直到hi>top，并入栈，这个操作相当于把 i 的左边界向左移动，并挤出所有比它高的元素。每有一个元素出栈（当然是拓展后的），就计算它出栈时（当然，让他出栈的元素是他的最终右边界）的面积，这个面积就是最大面积的候选人。最后的最后，让0入栈，以清空栈表。这样一来，所有元素的左右最大边界都在O（n）的时间得到最充分的考虑。

附图：

代码

#include<iostream>
#include<stack>
using namespace  std;
struct oneday{
    long long int xfront=0;//向前延申最小坐标
    int ifront=0;//向前延申最小天数
    int i;//第i天
    long long int x;//横坐标
    long long int n;//幸福值
};
int main(){
    long long int M=0,M0;
    int i0,i1;

    int N;
    scanf("%d",&N);
    stack<oneday>a;

    int n=0;
    oneday x;
    for(int k=0;k<=N;k++){
        if(k!=N)scanf("%d",&n);
        else n=-1;

        x.n=n;x.ifront=x.i=k+1;
        if(a.size()){
            x.xfront=x.x=a.top().x+a.top().n;
            if(x.n>a.top().n){
                a.push(x);
            }else{
                long long int xfront,ifront;
                while(a.size()&&x.n<=a.top().n){
                    M0=a.top().n*(x.x-a.top().xfront);
                    if(M0>M){
                        M=M0;
                        i0=a.top().ifront;
                        i1=x.i-1;
                    }else if(M0==M){
                        if(x.i-1-a.top().ifront>i1-i0){
                            M=M0;
                            i0=a.top().ifront;
                            i1=x.i-1;
                        }
                    }
                    xfront=a.top().xfront;
                    ifront=a.top().ifront;
                    a.pop();
                }
                x.xfront=xfront;
                x.ifront=ifront;
                a.push(x);
            }
        }else{
            x.xfront=x.x=0;
            a.push(x);
        }
    }
    printf("%lld\\n%d %d",M,i0,i1);
    return 0;
}