数据结构与算法——编程作业——内排序&外排序

内排序

1-1.距离排序

总时间限制: 

1000ms

 

内存限制: 

65536kB

描述

给出三维空间中的n个点（不超过10个）,求出n个点两两之间的距离,并按距离由大到小依次输出两个点的坐标及它们之间的距离。

输入

输入包括两行，第一行包含一个整数n表示点的个数，第二行包含每个点的坐标(坐标都是整数)。点的坐标的范围是0到100，输入数据中不存在坐标相同的点。

输出

对于大小为n的输入数据，输出n*(n-1)/2行格式如下的距离信息：
(x1,y1,z1)-(x2,y2,z2)=距离
其中距离保留到数点后面2位。
(用cout输出时保留到小数点后2位的方法:cout<<fixed<<setprecision(2)<<x)

样例输入

4
0 0 0 1 0 0 1 1 0 1 1 1

样例输出

(0,0,0)-(1,1,1)=1.73
(0,0,0)-(1,1,0)=1.41
(1,0,0)-(1,1,1)=1.41
(0,0,0)-(1,0,0)=1.00
(1,0,0)-(1,1,0)=1.00
(1,1,0)-(1,1,1)=1.00

我的代码

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

//node
typedef struct{
    int x, y, z;
}NODE;
//edge
typedef struct{
    int n1, n2, l;
} EDGE;

int N, i, j, k = 0;
NODE * n;
EDGE * e;

//compare if e1 longer than e2
bool cmp(EDGE e1, EDGE e2){
    return e1.l > e2.l;
}
//calculate edge's length between node n1 & n2
int Len(int n1, int n2){
    int x = n[n1].x - n[n2].x,
        y = n[n1].y - n[n2].y,
        z = n[n1].z - n[n2].z;
    return x*x + y*y + z*z;
}
//bubble sort
void MySort(){
    EDGE t;
    for(i=0; i<k-1; ++i){
        for(j=k-1; j>i; --j){
            //edge[j] > edge[j-1]
            if(cmp(e[j], e[j-1])){
                t = e[j];
                e[j] = e[j-1];
                e[j-1] = t;
            }
        }
    }
}
//print result
void MyPrint(int m){
    int n1 = e[m].n1, n2 = e[m].n2, l = e[m].l;
    printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf
",
           n[n1].x, n[n1].y, n[n1].z,
           n[n2].x, n[n2].y, n[n2].z, sqrt((double)l));
}

int main(){
    //initialize
    scanf("%d", &N);
    n = new NODE[N+2];
    e = new EDGE[N*(N+1)/2+2];
    for(i=0; i<N; ++i)
        scanf("%d %d %d", &n[i].x, &n[i].y, & n[i].z);
    //calculate edges' length
    for(i=0; i<N-1; ++i)
        for(j=i+1; j<N; ++j){
            e[k].n1 = i;
            e[k].n2 = j;
            e[k].l = Len(i, j);
            k++;
        }
    //bubble sort
    MySort();
    //print result
    for(i=0; i<k; ++i)
        MyPrint(i);
    //delete
    delete [] n;
    delete [] e;
    return 0;
}

1-2.寻找中位数

总时间限制: 

1000ms

 

内存限制: 

65536kB

描述

在N（1<=N<10,000且N为奇数）个数中，找到中位数。

输入

第1行：N

第2至N+1行：每行是一个整数

输出

第一行：中位数

样例输入

5
2
4
1
3
5

样例输出
　　　　3

我的代码

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

int main(){
    int n, a[10010];
    scanf("%d", &n);
    for(int i = 0; i < n; ++i)
        scanf("%d", a + i);
    sort(a, a + n);
    printf("%d", a[n/2]);
    return 0;
}

1-3.数组取数

总时间限制: 

1000ms

 

内存限制: 

65536kB

描述

有一个整数数组A和一个目标整数T，希望从A中没有放回地取出两个数，使得两个数之差等于T。请问有多少种不同的取法？（取出的两个数分别相等时视为同一种取法）

输入

输入由两行组成。第一行为两个整型范围内的整数N和T，N为数组长度（N的范围是[2,100000]），T为目标整数。第二行为N个整数，表示数组A，每个整数的范围是[-1000000,1000000]。

输出

A中取出两个数之差为T的不同的取法的数目。

样例输入

6 1
1 3 2 1 2 2

样例输出

2

我的代码

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

int main(){
    int n, t, * a, cur, ans = 0;
    scanf("%d %d", &n, &t);
    if(t < 0) t = -t;
    a = new int[n+1];
    for(int i = 0; i < n; ++i)
        scanf("%d", a + i);
    sort(a, a + n);
    for(int i = 0; i < n; ){
        cur = a[i];
        for(int j = i + 1; j < n; ++j){
            if(a[j] - cur == t){
                ans++;
                break;
            }
            else if(a[j] - cur > t)
                break;
        }
        for(i = i + 1 ; a[i] == cur && i < n; ++i);
    }
    printf("%d
", ans);
    delete [] a;
    return 0;
}

2-1.Freda的越野跑

总时间限制: 

1000ms

 

内存限制: 

262144kB

描述

Freda报名参加了学校的越野跑。越野跑共有N人参加，在一条笔直的道路上进行。这N个人在起点处站成一列，相邻两个人之间保持一定的间距。比赛开始后，这N个人同时沿着道路向相同的方向跑去。换句话说，这N个人可以看作x轴上的N个点，在比赛开始后，它们同时向x轴正方向移动。
假设越野跑的距离足够远，这N个人的速度各不相同且保持匀速运动，那么会有多少对参赛者之间发生“赶超”的事件呢？

输入

第一行1个整数N。
第二行为N 个非负整数，按从前到后的顺序给出每个人的跑步速度。
对于50%的数据，2<=N<=1000。
对于100%的数据，2<=N<=100000。

输出

一个整数，表示有多少对参赛者之间发生赶超事件。

样例输入

5
1 3 10 8 5

样例输出

7

提示

我们把这5个人依次编号为A,B,C,D,E，速度分别为1,3,10,8,5。
在跑步过程中：
B,C,D,E均会超过A，因为他们的速度都比A快；
C,D,E都会超过B，因为他们的速度都比B快；
C,D,E之间不会发生赶超，因为速度快的起跑时就在前边。

我的代码

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

int n, a[100010];
long long ans = 0;

void Merge(int s, int m, int e){
    int b[100010], i = s, j = m+1, k = s;
    while(i <= m && j <= e){
        if(a[i] >= a[j])    //如果相等，取a[i]，以保证稳定性
            b[k++] = a[i++];
        else{
            b[k++] = a[j++];
            ans += j - k;   //在位置j的选手超过了j-k个人，来到了位置k
        }
    }
    while(i <= m) b[k++] = a[i++];
    while(j <= e) b[k++] = a[j++];
    for(k = s; k <= e; ++k)
        a[k] = b[k];
    return;
}

void MergeSort(int s, int e){
    if(s >= e) return;
    int mid = (s + e) / 2;
    MergeSort(s, mid);
    MergeSort(mid + 1, e);
    Merge(s, mid, e);
    return;
}

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

2-2.The Peanuts

总时间限制: 

1000ms

 

内存限制: 

65536kB

描述

Mr. Robinson and his pet monkey Dodo love peanuts very much. One day while they were having a walk on a country road, Dodo found a sign by the road, pasted with a small piece of paper, saying "Free Peanuts Here! " You can imagine how happy Mr. Robinson and Dodo were.

There was a peanut field on one side of the road. The peanuts were planted on the intersecting points of a grid as shown in Figure-1. At each point, there are either zero or more peanuts. For example, in Figure-2, only four points have more than zero peanuts, and the numbers are 15, 13, 9 and 7 respectively. One could only walk from an intersection point to one of the four adjacent points, taking one unit of time. It also takes one unit of time to do one of the following: to walk from the road to the field, to walk from the field to the road, or pick peanuts on a point.

According to Mr. Robinson's requirement, Dodo should go to the plant with the most peanuts first. After picking them, he should then go to the next plant with the most peanuts, and so on. Mr. Robinson was not so patient as to wait for Dodo to pick all the peanuts and he asked Dodo to return to the road in a certain period of time. For example, Dodo could pick 37 peanuts within 21 units of time in the situation given in Figure-2.

Your task is, given the distribution of the peanuts and a certain period of time, tell how many peanuts Dodo could pick. You can assume that each point contains a different amount of peanuts, except 0, which may appear more than once.

输入

The first line of input contains the test case number T (1 <= T <= 20). For each test case, the first line contains three integers, M, N and K (1 <= M, N <= 50, 0 <= K <= 20000). Each of the following M lines contain N integers. None of the integers will exceed 3000. (M * N) describes the peanut field. The j-th integer X in the i-th line means there are X peanuts on the point (i, j). K means Dodo must return to the road in K units of time.

输出

For each test case, print one line containing the amount of peanuts Dodo can pick.

样例输入

2
6 7 21
0 0 0 0 0 0 0
0 0 0 0 13 0 0
0 0 0 0 0 0 7
0 15 0 0 0 0 0
0 0 0 9 0 0 0
0 0 0 0 0 0 0
6 7 20
0 0 0 0 0 0 0
0 0 0 0 13 0 0
0 0 0 0 0 0 7
0 15 0 0 0 0 0
0 0 0 9 0 0 0
0 0 0 0 0 0 0

样例输出

37
28

我的代码

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

typedef struct {
    int i, j, pea;
} Point;

bool cmp(Point p1, Point p2){
    return p1.pea > p2.pea;
}

int myabs(int num){
    if(num < 0) return -num;
    else return num;
}

int T, M, N, K;
int cnt, ans;
Point p[2510];

void Init(){
    scanf("%d %d %d", &M, &N, &K);
    cnt = 0;
    ans = 0;
    int pea;
    for(int i = 0; i < M; ++i)
        for(int j = 0; j < N; ++j){
            scanf("%d", &pea);
            //record points with peanuts > 0
            if(pea){
                p[cnt].i = i;
                p[cnt].j = j;
                p[cnt].pea = pea;
                cnt++;
            }
        }
}

void PickPeanut(){
    //current: position [i][j], target p[cur]
    //time: initially time = 1 (road to field)
    int i = 0, j = p[0].j, cur = 0, time = 1;
    while(cur < cnt && time <= K){
        time += myabs(i - p[cur].i) + myabs(j - p[cur].j) + 1;
        if(time + p[cur].i + 1 <= K)    //can fetch p[cur]
            ans += p[cur].pea;
        else
            break;
        i = p[cur].i;
        j = p[cur].j;
        ++cur;
    }
    return;
}

int main(){
    scanf("%d", &T);
    while(T--){
        Init();
        sort(p, p + cnt, cmp);
        PickPeanut();
        printf("%d
", ans);
    }
    return 0;
}

2-3.DNA排序

总时间限制: 

1000ms

 

内存限制: 

65536kB

描述

现在有一些长度相等的DNA串（只由ACGT四个字母组成），请将它们按照逆序对的数量多少排序。

逆序对指的是字符串A中的两个字符A[i]、A[j]，具有i < j 且 A[i] > A[j] 的性质。如字符串”ATCG“中，T和C是一个逆序对，T和G是另一个逆序对，这个字符串的逆序对数为2。

输入

第1行：两个整数n和m，n(0<n<=50)表示字符串长度，m(0<m<=100)表示字符串数量

第2至m+1行：每行是一个长度为n的字符串

输出

按逆序对数从少到多输出字符串，逆序对数一样多的字符串按照输入的顺序输出。

样例输入

10 6
AACATGAAGG
TTTTGGCCAA
TTTGGCCAAA
GATCAGATTT
CCCGGGGGGA
ATCGATGCAT

样例输出

CCCGGGGGGA
AACATGAAGG
GATCAGATTT
ATCGATGCAT
TTTTGGCCAA
TTTGGCCAAA

我的代码

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

typedef struct{
    char s[55];
    int n;
} String;

bool cmp(String s1, String s2){
    return s1.n < s2.n;
}

String str[105];
char s[55];
int m, n;

int Merge(int st, int mid, int end){
    int i = st, j = mid + 1, k = st, ans = 0;
    char s1[55];
    while(i <= mid && j <= end){
        if(s[i] <= s[j])
            s1[k++] = s[i++];
        else{
            s1[k++] = s[j++];
            ans += j-k;
        }
    }
    while(i <= mid) s1[k++] = s[i++];
    while(j <= end) s1[k++] = s[j++];
    for(k = st; k <= end; ++k)
        s[k] = s1[k];
    return ans;
}

int MergeSort(int st, int e){
    if(st >= e) return 0;
    int mid = (st + e) / 2;
    return MergeSort(st, mid) + MergeSort(mid+1, e) + Merge(st, mid, e);
}

int main(){
    scanf("%d %d", &n, &m);
    for(int i = 0; i < m; ++i){
        scanf("%s", str[i].s);
        strcpy(s, str[i].s);
        str[i].n = MergeSort(0, n-1);
    }
    sort(str, str + m, cmp);
    for(int i = 0; i < m; ++i)
        printf("%s
", str[i].s);
    return 0;
}

外排序

1.置换选择排序

总时间限制: 

1000ms

 

内存限制: 

65536kB

描述

给定初始整数顺串，以及大小固定并且初始元素已知的二叉最小堆（为完全二叉树或类似完全二叉树，且父元素键值总小于等于任何一个子结点的键值），要求利用堆实现置换选择排序，并输出第一个顺串。例如给定初始顺串29,14,35,13,以及堆（记为16 19 31 25 21 56 40）， 置换选择排序得到的第一个顺串为16 19 21 25。

输入

第一行包含两个整数，m为初始顺串的数的个数，n为二叉最小堆的大小
第二行包含m个整数，即初始顺串
第三行包含n个整数，即已经建好的堆的元素（有序，按照从堆顶到堆底，从左到右的顺序）

输出

输出包含一行，即第一个顺串。

样例输入

4 7
29 14 35 13
16 19 31 25 21 56 40

样例输出

16 19 21 25

我的代码

# include <iostream>
using namespace std;

int m, n, * heap, * num;

void Init(){
    cin >> m >> n;
    heap = new int [n+1];
    num = new int [m+1];
    for(int i=0; i<m; ++i)
        cin >> num[i];
    for(int i=0; i<n; ++i)
        cin >> heap[i];
}

void Exch(int i, int j){
    int tmp = heap[i];
    heap[i] = heap[j];
    heap[j] = tmp;
}

void ShiftDown(){
    int cur = 0, s1 = 1, s2 = 2;
    while(s2 < n){
        if(heap[cur] <= heap[s1] && heap[cur] <= heap[s2])
            return; //heap is min heap already
        if(heap[s1] > heap[s2]){
            Exch(cur, s2);
            cur = s2;
        }
        else{
            Exch(cur, s1);
            cur = s1;
        }
        s1 = cur * 2 + 1;
        s2 = s1 + 1;
    }
    if(s1 < n && heap[s1] < heap[cur])
        Exch(cur, s1);
    return;
}

void Insert(){
    //attention! n should > 0
    for(int i=0; i<m && n; ++i){
        cout << heap[0] << ' ';
        if(num[i] >= heap[0])
            heap[0] = num[i];
        else
            heap[0] = heap[--n];
        ShiftDown();
    }
}

void Dele(){
    delete [] heap;
    delete [] num;
}

int main(){
    Init();
    Insert();
    Dele();
    return 0;
}

2.败方树

总时间限制: 

1000ms

 

内存限制: 

65536kB

描述

给定一个整数数组，要求对数组中的元素构建败方树（数组相邻元素两两比较，从第一个元素开始）。之后修改数组中的元素，要求输出初始构建以及修改后得到的败方树的所有内部结点代表的整数(从左到右从上到下输出）

输入

第一行为数组的元素个数n和修改的次数m。
第二行为n个整数，即数组的元素。
接下来m行代表m次修改操作，每次操作修改数组中的一个元素，每一行包括两个整数，第一个为被修改元素在数组中的标号，第二个为修改之后的元素值。

输出

输出m+1行。
第一行为初始构建的败方树的所有内部结点代表的整数(按照树的结点从左到右从上到下的顺序输出）
接下来m行为接下来m次修改后得到的败方树的所有内部结点代表的整数(按照树的结点从左到右从上到下的顺序输出）

样例输入

8 1
10 9 20 6 16 12 90 17
3 15

样例输出

6 12 9 17 10 20 16 90
9 12 15 17 10 20 16 90

我的代码

# include <iostream>
using namespace std;

struct LoserTree{
    int n;      // elements to be compared: n
    int LowExt; // lowest external elements number: LowExt
    int s;      // lowest internal level elements: s
    int offset; // total nodes numbers except lowest level
    int * tree; // loser tree
    int * ele;  // elements to be compared
    int winner(int c1, int c2);         // return winner index
    int loser(int c1, int c2);          // return loser index
    void init(int _n, int * _ele);      // initialize loser tree
    void play(int p, int c1, int c2);   // compare ele[c1] & [c2], their parent is p
    void build();   // rebuile loser tree
    void print();   // print tree
    void dele();    // delete tree
};

int LoserTree::winner(int c1, int c2){
    if(ele[c1] < ele[c2]) return c1;
    else return c2;
}

int LoserTree::loser(int c1, int c2){
    if(ele[c1] < ele[c2]) return c2;
    else return c1;
}

void LoserTree::init(int _n, int * _ele){
    ele = _ele;
    n = _n;
    tree = new int [n];
    for(s = 1; s*2 < n; s *= 2);
    offset = 2 * s - 1;
    LowExt = 2 * (n - s);
}

void LoserTree::play(int p, int c1, int c2){
    int lastwin = winner(c1, c2), tempwin;
    tree[p] = loser(c1, c2);
    while(p > 1 && p % 2 == 1){ // right subtree goes up
        tempwin = winner(lastwin, tree[p/2]);
        tree[p/2] = loser(lastwin, tree[p/2]);
        lastwin = tempwin;
        p /= 2;
    }
    tree[p/2] = lastwin;    // p = 1, or tree[p] is a left sibling
}

void LoserTree::build(){
    int i;
    // lowest level elements play
    for(i = 2; i <= LowExt; i += 2)
        play((offset+i)/2, i-1, i);
    // one inner node vs one element
    if(n % 2){
        play(n/2, tree[n-1], LowExt+1);
        i = LowExt + 3;
    }
    else i = LowExt + 2;
    // the last second level elements play
    for( ; i <= n; i += 2)
        play((i-LowExt+n-1)/2, i-1, i);
}

void LoserTree::print(){
    for(int i = 0; i < n; ++i)
        cout << ele[tree[i]] << ' ';
    cout << endl;
}

void LoserTree::dele(){
    delete [] tree;
}

int main(){
    int n, m, * ele, index, val;
    LoserTree MyTree;
    cin >> n >> m;
    ele = new int [n+2];
    for(int i=1; i<=n; ++i)
        cin >> ele[i];
    MyTree.init(n, ele);
    MyTree.build();
    MyTree.print();
    for(int i=0; i<m; ++i){
        cin >> index >> val;
        ele[index+1] = val; // change value if ele[index]
        MyTree.build();     // rebuild
        MyTree.print();
    }
    MyTree.dele();
    delete [] ele;  // don't dorget!!!
    return 0;
}