数据结构与算法——2018期末机考练习

写在前面

1.2018期末机考题目网址：

(1)普通班：http://dsa.openjudge.cn/final20181223

(2)实验班：http://dsa.openjudge.cn/final2018ht

2.2018期末机考模拟测试：

http://dsa.openjudge.cn/2018ftest/

3.参考资料下载地址

(1)http://media.openjudge.cn/upload/DSMooc/DSCode_ZhangWangZhao2008_06.rar

(2)http://media.openjudge.cn/upload/DSMooc/DScodeCversion.rar (C语言代码包)

(3)http://media.openjudge.cn/upload/DSMooc/201810cplusplus.zip (C++手册)

(4)http://media.openjudge.cn/upload/DSMooc/DSAlgoWeissMark.pdf (英文教材)

 

1.词典

其他网址：http://bailian.openjudge.cn/practice/2804/

题目　　

总时间限制: 

3000ms

内存限制: 

65536kB

描述

你旅游到了一个国外的城市。那里的人们说的外国语言你不能理解。不过幸运的是，你有一本词典可以帮助你。

输入

首先输入一个词典，词典中包含不超过100000个词条，每个词条占据一行。每一个词条包括一个英文单词和一个外语单词，两个单词之间用一个空格隔开。而且在词典中不会有某个外语单词出现超过两次。词典之后是一个空行，然后给出一个由外语单词组成的文档，文档不超过100000行，而且每行只包括一个外语单词。输入中出现单词只包括小写字母，而且长度不会超过10。

输出

在输出中，你需要把输入文档翻译成英文，每行输出一个英文单词。如果某个外语单词不在词典中，就把这个单词翻译成“eh”。

样例输入

dog ogday
cat atcay
pig igpay
froot ootfray
loops oopslay

atcay
ittenkay
oopslay

样例输出

cat
eh
loops

提示

　　输入比较大，推荐使用C语言的I / O函数。

来源
　　翻译自Waterloo local 2001.09.22的试题

我的代码

# include <iostream>
# include <cstdio>
# include <algorithm>
# include <string.h>
using namespace std;

//type: DIC
typedef struct{
    char w1[12], w2[12];
} DIC;

//d1.w1 < d2.w1
bool cmp(DIC d1, DIC d2){
    return (strcmp(d1.w2, d2.w2) < 0);
}


DIC d[100010];  //dictionary: increasing order
int n = 0;      //n pairs of words in dic
char s[25];     //input strings s[]

//initialize dictionary: separate 2 words
void IniDic(int num){
    int pos;
    for(pos = 0; s[pos] != ' '; ++pos);
    strncpy(d[num].w1, s, pos);
    strncpy(d[num].w2, s+pos+1, 11);
}

//binary search: lookfor word s[]
void SearchWord(){
    int r = 0, l = n - 1, m, t;   //first, last, middle
    while(r < l){
        m = (r + l) / 2;
        if((t = strcmp(s, d[m].w2)) == 0){
            printf("%s
", d[m].w1);
            return;     //find s = d[m].w1
        }
        else if(t > 0)  //s > d[m].w1
            r = m + 1;
        else            //s < d[m].w1
            l = m - 1;
    }
    if(strcmp(s, d[r].w2) == 0)
        printf("%s
", d[r].w1);
    else
        printf("eh
");
    return;
}

int main(){
    while((s[0] = cin.get()) != '
'){
        cin.getline(s+1, 24);
        IniDic(n++);
    }
    //cout << n << endl;
    sort(d, d+n, cmp);  //sort dictionary
    //for(int i = 0; i < n; ++i)
        //printf("dic[%d]: %s %s
", i, d[i].w1, d[i].w2);
    while(cin >> s){
        SearchWord();
    }
    return 0;
}

tips

1.空行的识别,get(),cin.getline()等

2.单词排序：定义比较函数<template T> bool cmp(T t1, T t2);

3.单词查找：二分查找

 

 

2.Field Reduction

来源：USACO 2016 US Open contest

题目 

总时间限制: 

10000ms

 

单个测试点时间限制: 

1000ms

 

内存限制: 

65536kB

描述

Farmer John's N cows (5≤N≤50,000) are all located at distinct positions in his two-dimensional field. FJ wants to enclose all of the cows with a rectangular fence whose sides are parallel to the x and y axes, and he wants this fence to be as small as possible so that it contains every cow (cows on the boundary are allowed). FJ is unfortunately on a tight budget due to low milk production last quarter. He would therefore like to build an even smaller fenced enclosure if possible, and he is willing to sell up to three cows from his herd to make this possible. Please help FJ compute the smallest possible area he can enclose with his fence after removing up to three cows from his herd (and thereafter building the tightest enclosing fence for the remaining cows). For this problem, please treat cows as points and the fence as a collection of four line segments (i.e., don't think of the cows as "unit squares"). Note that the answer can be zero, for example if all remaining cows end up standing in a common vertical or horizontal line.  

农夫约翰的N(5<=N<=50000)头牛被定在了平面内的不同的位置。他想用栅栏(平行于x和y轴)围住所有的牛。他想这个栅栏尽可能小(牛在边界上也被视作围住)。

他因为牛奶产量低而感到经费紧张，所以他想卖掉三头牛再围起剩下的牛。请算出栅栏围出的最小面积。(面积有可能为0，例如，最后剩下的牛排成一排或一列。）

输入

The first line of input contains N. The next N lines each contain two integers specifying the location of a cow. Cow locations are positive integers in the range 1…40,000.

第一行输入正整数n

剩下2-n+1行，输入每头牛的坐标位置(x,y) ( 1<= x,y<=40000的整数）

输出

Write a single integer specifying the minimum area FJ can enclose with his fence after removing up to three carefully-chosen cows from his herd.

最小面积

样例输入

6
1 1
7 8
10 9
8 12
4 100
50 7

样例输出

12

思路

按x、y的大小分别排序，每次去掉xmin/xmax/ymin/ymax的一头牛，dfs或者直接枚举

我的代码

(只在本地测试了一些数据)

版本一：

# include <iostream>
# include <algorithm>
using namespace std;
#define MAXSPACE 2000000000

//cow's position
typedef struct{
    int x, y;
} COW;

//compare cow's x
bool cmpx(COW c1, COW c2){
    return c1.x < c2.x;
}

//compare cow's y
bool cmpy(COW c1, COW c2){
    return c1.y < c2.y;
}

int n;
COW * c;

//find min from 4 values
int MyMin(int a, int b, int c, int d){
    if(a < b){
        if(a < c){
            if(a < d) return a;
            else return d;
        }
        else{
            if(c < d) return c;
            else return d;
        }
    }
    else{
        if(b < c){
            if(b < d) return b;
            else return d;
        }
        else{
            if(c < d) return c;
            else return d;
        }
    }
}

//calculate min space needed after selling r cows from c[s~e-1]
int MinSpace(int s, int e, int r){
    if(r == 0){ //no cows to sell
        int x1, x2, y1, y2;
        sort(c+s, c+e, cmpx);
        x1 = c[s].x;
        x2 = c[e-1].x;
        sort(c+s, c+e, cmpy);
        y1 = c[s].y;
        y2 = c[e-1].y;
        return (x2-x1)*(y2-y1);
    }
    int mx1 = MAXSPACE, mx2 = MAXSPACE, my1 = MAXSPACE, my2 = MAXSPACE;
    sort(c+s, c+e, cmpx);
    //sell the cow with min-x
    //if c[s].x == c[s+3].x, then selling cow s won't make space smaller (from x's perspective)
    if(s+3 < e && c[s].x != c[s+3].x)
        mx1 = MinSpace(s+1, e, r-1);
    //sell the cow with max-x
    if(s+3 < e && c[e-4].x != c[e-1].x)
        mx2 = MinSpace(s, e-1, r-1);
    sort(c+s, c+e, cmpy);
    //sell the cow with min-y
    if(s+3 < e && c[s].y != c[s+3].y)
        my1 = MinSpace(s+1, e, r-1);
    //sell the cow with max-y
    if(s+3 < e && c[e-4].y != c[e-1].y)
        my2 = MinSpace(s, e-1, r-1);
    return MyMin(mx1, mx2, my1, my2);
}

int main(){
    cin >> n;
    c = new COW[n+1];
    for(int i = 0; i < n; ++i)
        cin >> c[i].x >> c[i].y;
    cout << MinSpace(0, n, 3) << endl;
    delete [] c;
    return 0;
}

有很多重复的sort，非常耗时

版本二：

# include <iostream>
# include <algorithm>
# include <cstdio>
using namespace std;
#define MAXSPACE 2000000000

//cow's position
typedef struct{
    int x, y;
} COW;

//compare cow's x
bool cmpx(COW c1, COW c2){
    return c1.x < c2.x;
}

//compare cow's y
bool cmpy(COW c1, COW c2){
    return c1.y < c2.y;
}

int n, ans = MAXSPACE;
COW * c;

//min value of a & b
int MyMin(int a, int b){
    if(a < b) return a;
    else return b;
}

//calculate space needed
//after selling x1 cows with min-x, x2 cows with max-x,
//and selling y1 cows with min-y, y2 cows with max-y
void Space(int x1, int x2, int y1, int y2){
    sort(c, c+n, cmpx);
    sort(c+x1, c+n-x2, cmpy);
    int miny = c[x1+y1].y, maxy = c[n-x2-y2-1].y;
    sort(c+x1+y1, c+n-x2-y2, cmpx);
    int minx = c[x1+y1].x, maxx = c[n-x2-y2-1].x;
    int s = (maxx - minx) * (maxy - miny);
    /* testing code */
    /*
    printf("%d %d %d %d %d
", x1,x2,y1,y2, s);
    printf("    x: %d-%d, y: %d-%d
    ", minx,maxx, miny, maxy);
    for(int i=0; i<n; ++i)
        printf("(%d,%d) ", c[i].x, c[i].y);
    printf("
");
    */
    ans = MyMin(s, ans);
}

int main(){
    cin >> n;
    c = new COW[n+1];
    for(int i = 0; i < n; ++i)
        cin >> c[i].x >> c[i].y;
    for(int i = 0; i <= 3; ++i)
        for(int j = 0; i+j <= 3; ++j)
            for(int k = 0; i+j+k <= 3; ++k)
                Space(i, j, k, 3-i-j-k);
    cout << ans << endl;
    delete [] c;
    return 0;
}

枚举要去掉的牛的位置和个数

 

 

3.Ultra-QuickSort

其他网址：http://bailian.openjudge.cn/practice/2299/

题目

总时间限制: 

7000ms

 

内存限制: 

65536kB

描述

In this problem, you have to analyze a particular sorting algorithm. The algorithm processes a sequence of n distinct integers by swapping two adjacent sequence elements until the sequence is sorted in ascending order. For the input sequence 
9 1 0 5 4 , 
Ultra-QuickSort produces the output 
0 1 4 5 9 . 
Your task is to determine how many swap operations Ultra-QuickSort needs to perform in order to sort a given input sequence. 

输入

The input contains several test cases. Every test case begins with a line that contains a single integer n < 500,000 -- the length of the input sequence. Each of the the following n lines contains a single integer 0 ≤ a[i] ≤ 999,999,999, the i-th input sequence element. Input is terminated by a sequence of length n = 0. This sequence must not be processed.

输出

For every input sequence, your program prints a single line containing an integer number op, the minimum number of swap operations necessary to sort the given input sequence.

样例输入

5
9
1
0
5
4
3
1
2
3
0

样例输出

6
0

来源

Waterloo local 2005.02.05

我的代码

# include <cstdio>
using namespace std;

int main(){
    int n, a[500000], cnt, tmp;
    scanf("%d", &n);
    while(n){
        cnt = 0;
        for(int i = 0; i < n; ++i)
            scanf("%d", a + i);
        for(int i = n - 1; i; --i)
            for(int j = 0; j < i; ++j){
                if(a[j] > a[j+1]){
                    tmp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = tmp;
                    ++cnt;
                }
            }
        printf("%d
", cnt);
        scanf("%d", &n);
    }
    return 0;
}

# include <cstdio>
using namespace std;

int main(){
    int n, a[500000], cnt, tmp;
    bool f;    //flag
    scanf("%d", &n);
    while(n){
        cnt = 0;
        for(int i = 0; i < n; ++i)
            scanf("%d", a + i);
        for(int i = n - 1; i; --i){
            f = 1;            //flag
            for(int j = 0; j < i; ++j){
                if(a[j] > a[j+1]){
                    tmp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = tmp;
                    ++cnt;
                    f = 0;    //flag
                }
            }
            if(f) break;
        }
        printf("%d
", cnt);
        scanf("%d", &n);
    }
    return 0;
}

冒泡(复杂度O(n^2))妥妥TLE

换了归并(复杂度O(nlgn))，终于AC

# include <cstdio>
using namespace std;

//length n, array a[], temp array t[]
int n, a[500000], t[500000];

//Merge(start, middle, end)
long long Merge(int s, int m, int e){
    int i = s, j = m+1, k = s;
    long long cnt = 0;
    while(i <= m && j <= e){
        if(a[i] < a[j])
            t[k++] = a[i++];
        else{
            t[k++] = a[j++];
            cnt += j - k;   //a[j] go to a[k] needs j-k exchanges
        }
    }
    while(i <= m) t[k++] = a[i++];
    while(j <= e) t[k++] = a[j++];
    for(int l = s; l <= e; ++l)
        a[l] = t[l];
    return cnt;
}

//Divide & sort & merge
long long MergeSort(int s, int e){
    if(s >= e) return 0;    //exit of recursion
    int m = (s + e) / 2;
    long long ret = 0;
    ret += MergeSort(s, m);     //sort a[s~m]
    ret += MergeSort(m + 1, e); //sort a[m+1~e]
    ret += Merge(s, m, e);      //merge a[s~m] & a[m+1~e]
    return ret;
}

int main(){
    scanf("%d", &n);
    while(n){
        for(int i = 0; i < n; ++i)
            scanf("%d", a + i);
        printf("%lld
", MergeSort(0, n-1));
        scanf("%d", &n);
    }
    return 0;
}

tips：

1.注意数据类型用long long (亲测int会WA)

2.采用归并排序，记录归并过程中记录交换次数(AC代码第16行：cnt += j-k 或 cnt += m-i+1)

 

 

4.表达式·表达式树·表达式求值

其他网址：http://dsa.openjudge.cn/tree/0609/

题目

总时间限制: 

1000ms

 

内存限制: 

65535kB

描述

众所周知，任何一个表达式，都可以用一棵表达式树来表示。例如，表达式a+b*c，可以表示为如下的表达式树：

   +
  /
a   *
    /
    b c

现在，给你一个中缀表达式，这个中缀表达式用变量来表示（不含数字），请你将这个中缀表达式用表达式二叉树的形式输出出来。

输入

输入分为三个部分。
第一部分为一行，即中缀表达式(长度不大于50)。中缀表达式可能含有小写字母代表变量（a-z），也可能含有运算符（+、-、*、/、小括号），不含有数字，也不含有空格。
第二部分为一个整数n(n < 10)，表示中缀表达式的变量数。
第三部分有n行，每行格式为C　x，C为变量的字符，x为该变量的值。

输出

输出分为三个部分，第一个部分为该表达式的逆波兰式，即该表达式树的后根遍历结果。占一行。
第二部分为表达式树的显示，如样例输出所示。如果该二叉树是一棵满二叉树，则最底部的叶子结点，分别占据横坐标的第1、3、5、7……个位置（最左边的坐标是1），然后它们的父结点的横坐标，在两个子结点的中间。如果不是满二叉树，则没有结点的地方，用空格填充（但请略去所有的行末空格）。每一行父结点与子结点中隔开一行，用斜杠（/）与反斜杠（）来表示树的关系。/出现的横坐标位置为父结点的横坐标偏左一格，出现的横坐标位置为父结点的横坐标偏右一格。也就是说，如果树高为m，则输出就有2m-1行。
第三部分为一个整数，表示将值代入变量之后，该中缀表达式的值。需要注意的一点是，除法代表整除运算，即舍弃小数点后的部分。同时，测试数据保证不会出现除以0的现象。

样例输入

a+b*c
3
a 2
b 7
c 5

样例输出

abc*+
   +
  / 
 a   *
    / 
    b c
37

我的代码 

# include <iostream>
# include <cstdio>
# include <stack>
using namespace std;

char a[20], b[20], c;   //input a[], answer b[]
char ** pic;    //picture of tree
int v[30], n, t;//v[] store values
int len;        //len = lenght of b[]
int pos;        //current index when biulding tree
int dep = 0;    //depth of tree
stack<int> st1; //help calculate

//define Node of binary tree
typedef struct NODE{
    char c;     //symbol of node
    int d;      //depth of node
    NODE *l, *r;//pointer to children
} Node;

Node * root, * cur;

//biuld the subtree with root b[l]
Node * BiuldSubtree(int d){
    Node * tmp = new Node;
    tmp->c = b[pos--];        //set node's symbol
    tmp->d = d;             //set node's depth
    if(d > dep) dep = d;    //renew depth of tree
    if(tmp->c >= 'a' && tmp->c <= 'z')
        tmp->l = tmp->r = NULL; //leaf nodes (variables)
    else{                       //branch nodes (operators)
        tmp->r = BiuldSubtree(d+1);
        tmp->l = BiuldSubtree(d+1);
    }
    return tmp;
}
//Biuld binary tree
void BiuldTree(){
    pos = len-1;  //current position of b[]
    root = BiuldSubtree(0);
    //printf("depth = %d
", dep);
}
//delete Tree
void DelTree(Node * ptr){
    if(ptr == NULL) return;
    DelTree(ptr->l);
    DelTree(ptr->r);
    delete ptr;
}
//Draw the subtree ptr pointing to from (si, sj) in pic[][]
void DrawSubtree(Node * ptr, int si, int sj){
    if(ptr == NULL) return;     //draw nothing
    int i = si, j = sj + (1<<(dep-ptr->d)) - 1;
    pic[i][j] = ptr->c;
    if(ptr->l == NULL) return;  //leaf node
    pic[i+1][j-1] = '/';
    pic[i+1][j+1] = '\';
    DrawSubtree(ptr->l, i+2, sj);
    DrawSubtree(ptr->r, i+2, j+1);
}
//print binary tree
void PrintTree(){
    int h = dep*2+1, w = 1<<(dep+1);
    int i, j;
    //initialize pic[][]
    pic = new char * [h];
    for(i = 0 ; i < h; ++i){
        pic[i] = new char[w];
        for(j = 0; j < w; ++j)
            pic[i][j] = ' ';
    }
    //draw nodes in pic[][]
    DrawSubtree(root, 0, 0);
    //don't print ending spaces
    for(i = 0 ; i < h; ++i){
        for(j = w-1; pic[i][j] == ' '; --j);
        pic[i][j+1] = '';
        printf("%s
", pic[i]);
    }
}


//print reverse Polish notation b[]
void PrintB(){
    stack<char> st;
    len = 0;
    for(int i = 0; a[i]; ++i){
        switch(a[i]){
            case '(': st.push(a[i]); break;
            case ')':
                while((c = st.top()) != '('){
                    b[len++] = c;
                    st.pop();
                }
                st.pop(); break;
            case '+':
            case '-':
                while(!st.empty() && (c = st.top()) != '('){
                    b[len++] = c;
                    st.pop();
                }
                st.push(a[i]); break;
            case '*':
            case '/':
                while(!st.empty() && ((c = st.top()) == '*' || c == '/')){
                    b[len++] = c;
                    st.pop();
                }
                st.push(a[i]); break;
            default:    //variables
                b[len++] = a[i];
        }
    }
    while(!st.empty()){     //don't forget remaining symbols
        b[len++] = st.top();
        st.pop();
    }
    printf("%s
", b);
}

//calculate t3 = t1 op t2
void Cal2Nums(char op){
    int t1, t2, t3;
    //t1 under t2, pop t2 first
    t2 = st1.top(); st1.pop();
    t1 = st1.top(); st1.pop();
    switch(op){
        case '+': t3 = t1 + t2; break;
        case '-': t3 = t1 - t2; break;
        case '*': t3 = t1 * t2; break;
        case '/': t3 = t1 / t2; break;
        default:
            printf("Error in Cal2Nums
!!");
            exit(0);
    }
    st1.push(t3);
}
//calculate answer of b[]
void CalAns(){
    for(int i = 0; b[i]; ++i){
        if(b[i] >= 'a' && b[i] <= 'z')
            st1.push(v[b[i]-'a']);
        else
            Cal2Nums(b[i]);
    }
    printf("%d
", st1.top());
    st1.pop();
}


int main(){
    cin >> a >> n;
    for(int i = 0; i < n; ++i){
        cin >> c >> t;
        v[c-'a'] = t;
    }
    PrintB();
    BiuldTree();
    PrintTree();
    DelTree(root);
    CalAns();
    return 0;
}

思路不难，就是麻烦，估计考试的时候写不完quq

 

5.Angry Cows

题目

总时间限制: 

10000ms

 

单个测试点时间限制: 

1000ms

 

内存限制: 

65536kB

描述

奶牛Bessie设计了一个游戏：“愤怒的奶牛”。游戏的原型是：有一些可爆燃的草堆分布在一条数轴的不同坐标，玩家用弹弓把奶牛发射到数轴上。牛奶砸到数轴上的冲击波会引发附近的草堆燃爆，并有可能引起附近的草堆连环燃爆。游戏的目标是玩家用一些奶牛燃爆所有的草堆。 有N个草堆在数轴的不同位置，坐标为x1,x2,….,xn。如果玩家把奶牛发射到坐标是x，能量是R，就会引爆半径R以内的的草堆，即坐标范围[x-R, x+R]的草堆都会燃爆。 现在有K头奶牛，每头奶牛的能量都是R，请计算

输入

第一行：2个整数N( 1 ≤ N ≤ 50,000)和K( 1 ≤ K ≤ 10)。
下面有N行,每行一个整数：x1, x2 ,…,xn，范围在[0…1,000,000,000]

输出

输出最小可能的整数R。

样例输入

7 2
20
25
18
8
10
3
1

样例输出

5

提示

说明：只有一开始的牛会产生的爆炸，范围为R，草堆并不会爆炸，只会受到牛能量的影响被引燃。

我的代码 

 

# include <iostream>
# include <cstdio>
# include <algorithm>
using namespace std;

int N, K;
int * pos, rmax, rmin, r, ans;

int findnext(int i, int p){
    for(i += 1; i < N && pos[i] <= p; ++i);
    return i;
}

int main(){
    scanf("%d %d", &N, &K);
    pos = new int[N+1];
    for(int i=0; i<N; ++i)
        scanf("%d", pos+i);
    sort(pos, pos+N);
    
    rmin = 0;
    rmax = (pos[N-1]-pos[0]) / (2*K) + 1;
    while(rmin < rmax){
        r = (rmin+rmax) / 2;
        int k=0, i=0;
        while(i < N){
            ++k;
            i = findnext(i, pos[i] + 2 * r);
        }
        if(k > K) rmin = r + 1;
        else rmax = r;
    }
    printf("%d
", rmin);
    delete [] pos;
    return 0;
}

 

6.广告计划

题目

总时间限制: 

20000ms

 

单个测试点时间限制: 

2000ms

 

内存限制: 

65536kB

描述

作为一个新广告项目的一部分，氪星的一家大公司打算把自己的logo在城市的某个地方展示。这家公司打算把这一整年的广告预算都花在这个大logo上，所以它将会非常非常的大。公司的一位高管打算使用整个建筑作为logo的一部分。

Logo由n个不同高度的柱子构成，从左到右编号为1到n。logo可以用编号1，2，……，n的一个排列（s1,s2...,sn)描述。其中s1代表最矮的柱子，s2是第二矮的，以此类推sn是最高的柱子。柱子的实际高度并不重要。

氪星的主干道旁有m栋建筑，很奇怪的是这些建筑的高度是不同的。现在的问题是找到所有可以与logo匹配的建筑的位置。

帮助公司找到建筑序列中所有可以与logo匹配的连续的部分，要求如下：s1最矮，s2是第二矮的，以此类推。例如一组建筑的高度为5，10，4和用排列（3，1，2）描述的logo是匹配的，因为3号建筑高为4，是最矮的，1号建筑是第二矮的而建筑2是最高的。

输入

第一行包含两个整数n和m（2<=n<=m<=1000000）.
第二行包含n个整数，描述了序号1到n的一个排列si,其中1≤si≤n,si≠sj for i≠j .
第三行包含m个整数，表示了每栋楼的高度（小于等于10的9次方），其中两两不同，用空格分开。

输出

第一行，整数k，匹配的个数。
第二行包含k个整数，表示匹配的位置，升序表示，如果k为0，则第二行为空。

样例输入

5 10
2 1 5 3 4
5 6 3 8 12 7 1 10 11 9

样例输出

2
2 6

提示

说明：6，3，8，12，7和7，1，10，11，9都可以匹配（2，1，5，3，4），在第一个序列中，2号建筑高为3是最矮的，1号是第二矮的，接下来是5号建筑高度为7排第三，最高的是4号高度为12.（如图）

我的代码

# include <cstdio>
# include <iostream>
# include <algorithm>
using namespace std;

int main(){
    int n, m, * s, * h;
    int tmp, cnt = 0, * ans;
    bool f;
    scanf("%d %d", &n, &m);
    s = new int[n+2];
    h = new int[m+2];
    ans = new int[m-n+2];
    for(int i = 0; i < n; ++i)
        scanf("%d", s + i);
    for(int i = 0; i < m; ++i)
        scanf("%d", h + i);
    for(int i = -1; i < m - n; ++i){
        f = 1;      //start from i is OK
        tmp = h[i+s[0]];   //current height
        for(int j = 1; j < n; ++j){
            if(tmp >= h[i+s[j]])
            {   f = 0; break; }
            else
                tmp = h[i+s[j]];
        }
        if(f)
            ans[cnt++] = i+2;
    }
    printf("%d
", cnt);
    for(int i = 0; i < cnt; ++i)
        printf("%d ", ans[i]);
    delete [] s;
    delete [] h;
    delete [] ans;
    return 0;
}

太暴力了，果然TLE... 毕竟去年考试只有14人通过orz

我还没AC...