JLU数据结构上机实验3

7-1 二叉树最长路径

原题呈现：

解题思路 ： 做过的习题了，这里不再赘述。

以下是AC代码：

#include <bits/stdc++.h>
using namespace std;

/*以下为二叉树的内容*/
typedef struct tree {
    int data;
    struct tree* left;
    struct tree* right;
}treetype;
typedef treetype* ptreetype;
ptreetype t, p;

int sum, i, res;

//根据带空指针的先根序列建树
ptreetype CBT(char tostop, ptreetype t) {
    int ch;
    cin >> ch;
    if (i==sum)
        return t;
    if (ch == tostop) {
        t = NULL;
        return t;
    }
    else {
        t = new tree;
        t->data = ch;    
        t->left = CBT(tostop, t->left);
        t->right = CBT(tostop, t->right);
        i++;
    }

    return t;
}

int h(ptreetype t) {
    if (t == NULL)
        return -1;
    return max(h(t->left), h(t->right)) + 1;
}

queue <int> q;

void lp(ptreetype t) {
    if (t == NULL)
        return;
    p = t;
    while (p != NULL) {
        q.push(p->data);
        res++;
        if (p->left == NULL || (p->left != NULL && p->right != NULL && h(p->right) >= h(p->left)))
            p = p->right;
        else
            p = p->left;
    }
}

int main(void)
{
    cin >> sum;
    p = CBT(-1,t);
    lp(p);
    printf("%d\n", res-1);
    while (!q.empty()) {
        printf("%d", q.front());
        q.pop();
        if (!q.empty())
            printf(" ");
    }
}

解后反思： 典型的运用递归思想的题目。

7-2 森林的层次遍历

原题呈现：

解题思路 ：
*模拟徒手构建森林的过程。
*数组a保存结点的数据域，数组b保存结点对应的度，数组alayer保存每个结点所对应的层数，数组layer保存每一层剩余的度数（这个比较抽象 ）。变量inow指示现在处理第inow的结点，变量layernow指示现在处于第layernow层。
*对于每一个结点，把它当前所在层数记入数组alayer中。如果它的度不为0，它现在所处层的剩余度数-1，增加一层，增加那一层的度数即为该结点的度；如果它的度为0，它现在所处层的度数-1，如果现在所处层的剩余度数已经为0，退回上一层，一直退到所处层的剩余度数不为0。最后数组alayer中就记录了所有点的层数，可以很方便地打印出层次遍历序列。

以下是根据这一思路写出的代码：

#include <bits/stdc++.h>
using namespace std;

char a[100001];
int alayer[1000001];
int b[100001];
int layer[100001];

int main(void)
{
	int n;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf(" %c", &a[i]);
	}
	for (int i = 0; i < n; i++) {
		scanf("%d", &b[i]);
	}
	int inow = 0, layernow=0;
	while (inow < n) {
		alayer[inow] = layernow;
		if (b[inow] != 0) {
			layer[layernow - 1]--;
			layer[layernow++] = b[inow];
		}
		else if (b[inow] == 0) {
			layer[layernow-1]--;
			while (layer[layernow-1]==0)
				layernow--;
		}
		inow++;
	}

	int count = 0;
	while (count<n) {
		for (int i = 0; i < n; i++) {
			if (alayer[i] == 0) {
				printf("%c", a[i]);
				if (count != n-1)
					printf(" ");
				count++;
			}
			alayer[i]--;
		}
	}
}

解后反思： 未必所有关于树的题目都要建树。

7-3 纸带切割

原题呈现：

解题思路 ： Huffman树的应用，故采用优先队列。此外，题目要求的是切割，解题时用了拼接的思想，故先进后出，采用栈。

以下是根据这一思路写出的代码：

#include <bits/stdc++.h>
using namespace std;

priority_queue <long long, vector<long long>, greater < long long >> pq;
stack <long long> s;

int main(void)
{
	int num;
	long long x, res=0;
	scanf("%d", &num);
	for (int i = 0; i < num; i++) {
		scanf("%lld", &x);
		pq.push(x);
	}
	while (!pq.empty()) {
		long long a= pq.top();
		pq.pop();
		long long b;
		if (!pq.empty()) {
			b = pq.top();
			pq.pop();
		}
		else
			b = 0;
		long long c = a + b;
		s.push(c);
		res += c;
		if (!pq.empty())
		pq.push(c);
	}
	if (num != 1) {
		printf("%lld\n", res);
		while (!s.empty()) {
			printf("%lld", s.top());
			s.pop();
			if (!s.empty())
				printf(" ");
		}
	}
	else
		printf("0");
}

解后反思： 注意特判切割的段数为1的情景。

7-4 序列乘积

原题呈现：

错误解题思路1 ： 单纯用优先队列保存所有值，并输出前n个。其实在第2层循环中压缩了遍历的范围，做了一点点优化

以下是根据这一思路写出的代码：

#include <bits/stdc++.h>
using namespace std;

priority_queue <long long, vector<long long>, greater < long long >> pq;
vector<int> a;
vector<int> b;

int main(void)
{
	int n, x;
	scanf("%d", &n);

	for (int i = 0; i < n; i++) {
		scanf("%d", &x);
		a.push_back(x);
	}
	sort(a.begin(), a.end());
	for (int i = 0; i < n; i++) {
		scanf("%d", &x);
		b.push_back(x);
	}
	sort(b.begin(), b.end());

	int p = n - 1;
	if (n > 15000)
		p = 15000;

	for (int i = 0; i <= p; i++) {
		for (int j = 0; j <= p/(i+1); j++) {
			pq.push(a[i] * b[j]);
		}
	}
	for (int i = 0; i < n; i++) {
		printf("%d", pq.top());
		pq.pop();
		if (i != n - 1)
			printf(" ");
	}
}

错因分析： 时空复杂度均过高

错误解题思路2 ： 听炫神说要维护一个只有n个元素的堆来降低空间复杂度，并且在一个元素出队后，将其所在的那行的下一个元素入队。于是用数组bflag[]保存每一行的进度。

以下是根据这一思路写出的代码：

#include <bits/stdc++.h>
using namespace std;

priority_queue <long long, vector<long long>, greater < long long >> pq;
vector<int> a;
vector<int> b;
int bflag[100001];

int main(void)
{
	int n, x, count=0;
	scanf("%d", &n);

	for (int i = 0; i < n; i++) {
		scanf("%d", &x);
		a.push_back(x);
	}
	for (int i = 0; i < n; i++) {
		scanf("%d", &x);
		b.push_back(x);
	}

	for (int j = 0; j < n; j++) {
		pq.push(a[0] * b[j]);
	}
	while (count < n) {
		x = pq.top();
		printf("%d",x);
		if (count != n - 1)
			printf(" ");
		pq.pop();
		count++;
		for (int j = 0; j < n; j++) {
			if (a[bflag[j]]*b[j]  == x) {
				bflag[j]++;
				pq.push(a[bflag[j]] * b[j]);
				break;
			}	
	    }
	}
}

错因分析： 空间复杂度降到合乎要求了，但是在定位出队的元素属于哪一行时依然要用到循环，导致时间复杂度还O(n^2)级。

正确解题思路 ： 开一个结构体优先队列，结构体中分别保存一个数的数值、所在的行数及列数，这样可以避免用循环定位出队元素的行、列数。

以下是根据这一思路写出的代码：

#include<bits/stdc++.h>
using namespace std;
vector<int> a;
vector<int> b;
struct node
{

	int ordx, ordy, data;
	bool operator<(const node& rhs)const
	{
		return data > rhs.data;
	}
	node(int x, int y, int v) :ordx(x), ordy(y), data(v) {};
};
priority_queue<node> q;
int main()
{
	int n, x;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", &x);
		a.push_back(x);
	}
	for (int i = 0; i < n; i++) {
		scanf("%d", &x);
		b.push_back(x);
		if (i == 0)
		{
			for (int j = 0; j < n; j++) {
				q.push(node(j, 0, a[j] * b[0]));
			}
		}
	}
	for (int i = 0; i < n; i++)
	{
		node tmp = q.top();
		printf("%d", tmp.data);
		q.pop();
		if (tmp.ordy < n) 
			q.push(node(tmp.ordx, tmp.ordy + 1, a[tmp.ordx] * b[tmp.ordy + 1]));
		if (i != n-1)
			printf(" ");
	}
}

解后反思： 终究还是眼界太窄，在看到炫神的代码前我根本不知道结构体优先队列的存在。