递归 on ZRJ | 学习笔记

斐波那契数列

Thu, 11 Oct 2012 11:13:00 +0800

见到一个题，让算斐波那契数列的第 n 项，手工推通项没推出来，记忆化递归如下

#include <stdio.h>

#define MAX 1024

int F[MAX] = {0};

int f(int n) {
	if (F[n] != 0) {
		return F[n];
	}
	F[n] = f(n-1) + f(n-2);
	return F[n];
}

int calc_f(int n) {
	if (n <= 0) {
		return -1;
	}
	F[1] = F[2] = 1;
	return f(n);
}

int main() {
	int n;
	while (EOF != scanf("%d", &n)) {
		printf("%dn", calc_f(n));
	}
	return 0;
}

输入输出

10
55

后来想起来一个非递归的 O(n) 方法

#include <stdio.h>

int f(int n) {
	if (n <= 0) {
		return -1;
	}
	if (n==1 || n==2) {
		return 1;
	}
	int a = 1;
	int b = 1;
	n -= 2;
	while (1)
	{
		a = a + b;
		if (--n <= 0)
		{
			return a;
		}
		b = a + b;
		if (--n <= 0)
		{
			return b;
		}
	}
}

int main() {
	int n;
	while (EOF != scanf("%d", &n)) {
		printf("%dn", f(n));
	}
	return 0;
}

最后耍赖上网看通项，http://en.wikipedia.org/wiki/Fibonacci_number，通项是

注意一下浮点转整型的向下取整，于是得到代码如下

#include <stdio.h>
#include <math.h>

int f(int n) {
	double q_5 = sqrt(5.0);
	double ans = (1/q_5)*pow((1+q_5)/2, n)-(1/q_5)*pow((1-q_5)/2, n);
	return ans+0.5;
}

int main() {
	int n;
	while (EOF != scanf("%d", &n)) {
		printf("%dn", f(n));
	}
	return 0;
}

果然通项公式是第一生产力啊。。

输出一个字符串的组合

Thu, 13 Sep 2012 18:36:10 +0800

跟上次输出一个字符串的排列类似，http://zrj.me/archives/472，要求输出一个字符串的组合，思路也是递归

#include <stdio.h>
#include <string.h>

void combine(char str[], int str_index, char res_total, char result[], int res_index)
{
	if (res_total == res_index)
	{
		for (int i=0; i<res_total; i++)
		{
			printf("%c ", result[i]);
		}
		printf("n");
	}
	else if (str_index==strlen(str))
	{
		return;
	}
	else
	{
		result[res_index] = str[str_index];
		combine(str, str_index+1, res_total, result, res_index+1);
		combine(str, str_index+1, res_total, result, res_index);
	}
}

int main()
{
	char str[100];
	char result[100];
	scanf("%s", str);
	for (int i = 1; i<=strlen(str); i++)
	{
		combine(str, 0, i, result, 0);
	}
	return 0;
}

输入输出

abcd
a
b
c
d
a b
a c
a d
b c
b d
c d
a b c
a b d
a c d
b c d
a b c d

可以发现没有考虑去重的情况，这个应该比较容易，就是预处理扫一遍，如果是 ascii 字符的话，那么把输入的 str 映射要一个位图上就可以了。

二叉树的遍历

Sat, 08 Sep 2012 17:01:31 +0800

参考 http://blog.csdn.net/acdnjjjdjkdckjj/article/details/6237970 写了二叉树的遍历，（基本上就是照抄的，囧），抄的时候感慨，stl 真是个好东西啊，另外，在三种次序遍历的实现上，递归的精巧发挥的淋漓尽致啊，还有就是非递归的遍历，设计真的好巧妙

#include <iostream>
#include <queue>
#include <stack>

using namespace std;

class Tree
{
public:
	char data;
	Tree *left;
	Tree *right;
	void create(Tree *&node);
	void preOrderVisit(Tree *node);
	void inOrderVisit(Tree *node);
	void lastOrderVisit(Tree *node);
	void levelOrderVisit(Tree *node);
	void notRecursionPreOrderVisit(Tree *node);
	void notRecursionInorderVisit(Tree *node);
	void notRecursionLastOrderVisit(Tree *node);
};

void Tree::create(Tree *&node)
{
	char ch;
	cin>>ch;
	if (ch == '0')
	{
		node = NULL;
	}
	else
	{
		node = new Tree();
		node->data = ch;
		create(node->left);
		create(node->right);
	}
}

void Tree::preOrderVisit(Tree *node)
{
	if (node)
	{
		cout<<node->data<<' ';
		preOrderVisit(node->left);
		preOrderVisit(node->right);
	}
}

void Tree::inOrderVisit(Tree *node)
{
	if (node)
	{
		inOrderVisit(node->left);
		cout<<node->data<<' ';
		inOrderVisit(node->right);
	}
}

void Tree::lastOrderVisit(Tree *node)
{
	if (node)
	{
		lastOrderVisit(node->left);
		lastOrderVisit(node->right);
		cout<<node->data<<' ';
	}
}

void Tree::levelOrderVisit(Tree *node)
{
	if ( ! node)
	{
		return;
	}
	queue<Tree *> q;
	q.push(node);
	while ( ! q.empty())
	{
		Tree *tmp = q.front();
		cout<<tmp->data<<' ';
		q.pop();
		if (tmp->left)
		{
			q.push(tmp->left);
		}
		if (tmp->right)
		{
			q.push(tmp->right);
		}
	}
}

void Tree::notRecursionPreOrderVisit(Tree *node)
{
	stack<Tree *> s;
	Tree *t = node;
	while (!s.empty() || t)
	{
		if (t)
		{
			cout<<t->data<<' ';
			s.push(t);
			t = t->left;
		}
		else
		{
			t = s.top();
			s.pop();
			t = t->right;
		}
	}
}

void Tree::notRecursionInorderVisit(Tree *node)
{
	stack<Tree *> s;
	Tree *t = node;
	while (!s.empty() || t)
	{
		if (t)
		{
			s.push(t);
			t = t->left;
		}
		else
		{
			t = s.top();
			s.pop();
			cout<<t->data<<' ';
			t = t->right;
		}
	}
}

void Tree::notRecursionLastOrderVisit(Tree *node)
{
	stack<Tree *> s;
	Tree *t = node;
	Tree *pre = NULL;
	while(!s.empty() || t)
	{
		while (t)
		{
			s.push(t);
			t = t->left;
		}
		t = s.top();
		if (t->right==NULL || t->right==pre)
		{
			cout<<t->data<<' ';
			pre = t;
			t = NULL;
			s.pop();
		}
		else
		{
			t = t->right;
		}
	}
}

int main()
{
	Tree *t = NULL;
	t->create(t);
	t->preOrderVisit(t);
	cout<<endl;
	t->inOrderVisit(t);
	cout<<endl;
	t->lastOrderVisit(t);
	cout<<endl;
	t->levelOrderVisit(t);
	cout<<endl;
	t->notRecursionPreOrderVisit(t);
	cout<<endl;
	t->notRecursionInorderVisit(t);
	cout<<endl;
	t->notRecursionLastOrderVisit(t);
	cout<<endl;
	return 0;
}

输入输出

124005003600700
1 2 4 5 3 6 7
4 2 5 1 6 3 7
4 5 2 6 7 3 1
1 2 3 4 5 6 7
1 2 4 5 3 6 7
4 2 5 1 6 3 7
4 5 2 6 7 3 1

输出一个字符串的全排列

Thu, 06 Sep 2012 20:44:02 +0800

今天看到 http://blog.csdn.net/morewindows/article/details/7370155 这里提出了一个问题

用C++写一个函数, 如 Foo(const char *str), 打印出 str 的全排列, 如 abc 的全排列: abc, acb, bca, dac, cab, cba

想了想（想了好久啊，好久没有碰数据结构和算法了），觉得可以 dfs，这样来搞：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX 1000

char str[MAX];
int len;
char tmp[MAX];
char used[MAX];

void arrange(int pos)
{
	if (pos >= len)
	{
		printf("%sn", tmp);
		return;
	}
	int i = 0;
	for (i=0; i<len; i++)
	{
		if ( ! used[i])
		{
			used[i] = 1;
			tmp[pos] = str[i];
			arrange(pos+1);
			used[i] = 0;
		}
	}
}

int main()
{
	scanf("%s", str);
	len = strlen(str);
	memset(used, 0, sizeof(used));
	memset(tmp, 0, sizeof(tmp));
	arrange(0);
	return 0;
}

结果如下：

但是问题是如果过滤掉重复的呢，最简单的一个想法是，用 stl 搞个 set，找到的结果先不打印出来，统统往 set 里面装，让 set 天然的帮我们过滤，最后用一个循环输出出来，但是，如果自己实现呢，回头看我们之前的代码，我们可以发现，在 dfs 的时候，字符在串中位置是有影响的，也就是说，对于上面的程序来说，abca 和 abac 是不一样的，但是，我们却希望，字符在串中的位置是无关紧要的，自然就想到，如果我们把相同的字符归成一群，这样就能解决问题，也就是说，我们需要把刚刚那两个串预处理一下，把他们都变成，一坨 a，然后一个 b，然后一个 c，于是得到下面的代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX 1000

typedef struct _letter {
	char ch;
	int count;
} letter;

letter letters[MAX];
int letters_arr_size = 0;

char input[MAX];
int len;
char tmp[MAX];

void preprocess();
void dfs(int pos);

int main()
{
	scanf("%s", input);
	len = strlen(input);
	preprocess();
	dfs(0);
	return 0;
}

void preprocess()
{
	memset(letters, 0, sizeof(letters));
	int i, j, found=0;
	for (i=0; i<len; i++)
	{
		found = 0;
		for (j=0; j<letters_arr_size; j++)
		{
			if (input[i] == letters[j].ch)
			{
				letters[j].count++;
				found = 1;
				break;
			}
		}
		if ( ! found)
		{
			letters[letters_arr_size].ch = input[i];
			letters[letters_arr_size].count = 1;
			letters_arr_size++;
		}
	}
}

void dfs(int pos)
{
	if (pos >= len)
	{
		printf("%sn", tmp);
		return;
	}
	int i;
	for (i=0; i<letters_arr_size; i++)
	{
		if (letters[i].count > 0)
		{
			letters[i].count--;
			tmp[pos] = letters[i].ch;
			dfs(pos+1);
			letters[i].count++;
		}
	}
}

结果如下

但是至于怎么把这段递归等价的改写成循环，想了很是有一会儿，可惜暂时没有想出来

历史评论

输出一个字符串的组合 | ZRJ (2012-09-13 18:36:14):

[…] 跟上次输出一个字符串的排列类似，http://zrj.me/archives/472，要求输出一个字符串的组合，思路也是递归 […]

生成可重集的排列 | ZRJ (2012-09-14 16:41:32):

[…] 118 页提到生成一个可重集的全排列问题，跟上次的生成一个字符串的全排列 […]