2015_3_21_greedy_algo

1000. Fibonacci 1
Total: 471 Accepted: 317
   
Time Limit: 1sec    Memory Limit:256MB
Description
In the Fibonacci integer sequence, F0 = 0, F1 = 1, and Fn = Fn-1 + Fn-2 for n ≥ 2. For example, the first ten terms of the Fibonacci sequence are:
 
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, …
 
Given an integer n, your goal is to compute the last Fn mod (10^9 + 7).
Input
 The input test file will contain a single line containing n (n ≤ 100).


There are multiple test cases!


Output
 For each test case, print the Fn mod (10^9 + 7).


Sample Input
 Copy sample input to clipboard
9
Sample Output
34

普通的递归搞定

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

double fib(int n){
	if (n == 0 || n == 1)
		return n;
	else
		return fib(n-1) + fib(n-2);
}

const int m = pow(10, 9) + 7;

int main(){
	int n;
	while (scanf("%d", &n) != EOF){
		printf("%ld\n", (long long)fib(n) % m);
	}
	return 0;
}

1001. Fibonacci 2
Total: 1007 Accepted: 231
   
Time Limit: 1sec    Memory Limit:256MB
Description
In the Fibonacci integer sequence, F0 = 0, F1 = 1, and Fn = Fn-1 + Fn-2 for n ≥ 2. For example, the first ten terms of the Fibonacci sequence are:
 
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, …
 
Given an integer n, your goal is to compute the last Fn mod (10^9 + 7).

Input
The input test file will contain a single line containing n (n ≤ 2^31-1).
There are multiple test cases!


Output
 For each test case, print the Fn mod (10^9 + 7).


Sample Input
 Copy sample input to clipboard
9
Sample Output
34
Hint
 You may need to use "long long".

这题用例巨大，显然不能再用递归。学习了一种新思路，模拟矩阵的乘法后利用矩阵快速幂求解

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;
const int maxn = 2;
const int mod = pow(10, 9) + 7;
int n = 2;	//矩阵大小
int num;	//幂大小

struct mat
{
    long long arr[maxn][maxn];
    mat(){
        memset(arr, 0, sizeof(arr));
    }
};

mat mul(mat a, mat b){
    mat ans;
    for(int i = 0; i < n; i++){			//代表左矩阵的行数 
        for(int k = 0; k < n; k++){		//代表右矩阵行数 
            if(a.arr[i][k]){
                for(int j = 0; j < n; j++){
               		ans.arr[i][j] += a.arr[i][k] * b.arr[k][j];
                	if(ans.arr[i][j] >= mod)
                    	ans.arr[i][j] = ans.arr[i][j] % mod;
            	}
            }
        }
    }
    return ans;
}

mat power(mat p,int k)
{
    if(k == 1) 
		return p;
		
    mat e;
    for(int i = 0; i < n; i++)
        e.arr[i][i] = 1;		//初始化为[1, 0; 0, 1] 
    if(k == 0) 
		return e;				//0次幂 就是e 
    while(k){
        if(k & 1)				//直到k 
            e = mul(e,p);
        p = mul(p,p);
        k >>= 1;
    }
    return e;
}

int main(){
    mat ori;					//题目中的原始矩阵[1, 1; 1, 0]
    ori.arr[0][0] = ori.arr[0][1] = ori.arr[1][0] = 1;
    while(scanf("%d", &num) != EOF){
        mat ans;
        ans = power(ori,num);
        printf("%ld\n", ans.arr[0][1]);
    }
    return 0;
}

1002. Huffman coding
Total: 561 Accepted: 152
   
Time Limit: 1sec    Memory Limit:256MB
Description


In computer science and information theory, a Huffman code is an optimal prefix code algorithm.


In this exercise, please use Huffman coding to encode a given data.


You should output the number of bits, denoted as B(T), to encode the data:


B(T)=∑f(c)dT(c),


where f(c) is the frequency of character c, and dT(c) is be the depth of character c's leaf in the tree T.


 
Input
The first line is the number of characters n.


The following n lines, each line gives the character c and its frequency f(c).


Output
 Output a single number B(T).


Sample Input
 Copy sample input to clipboard
5
0 5
1 4
2 6
3 2
4 3
Sample Output
45
Hint
0: 01
1: 00
2: 11
3: 100
4: 101

霍夫曼编码就是用尽可能短的码编出一长串数据，具体算法：

1.将各数据出现的频率放入优先队列（用最小堆实现），然后每次从堆中取出两个元素L, R，作为树中某节点的左右孩子。

2.将L+R之和丢回优先队列中，一直重复做直到堆中仅剩一个元素

3.根据树的层数，叶子节点代表一个编码对象，根为0，向下求出叶子结点层数之和

/*
5
0 2
1 5
2 6
3 8
4 10
*/
#include <queue>
#include <vector>
#include <cstdio>
using namespace std;

struct node{
	int freq;			//记录频率 
	int parent;			//记录parent的数组下标 
	int pos;			//记录本频率对应字符存储的位置 
	bool leaf;			//是否叶子节点 
	node(int f = -1, int pos = -1, bool lf = true){
		freq = f;
		this->pos = pos;
		parent = -1;
		leaf = lf;
	}
};

typedef struct{  
    bool operator()(node x, node y){  
        return x.freq > y.freq; 
    }  
}cmp;

node arr[2010];
int index = 0;
int main(){
	priority_queue<node, vector<node>, cmp> q;
	int n, freq;
	char ch;
	scanf("%d", &n);
	getchar();	
	for (int i = 0; i < n; i++){		//store freq in priority queue(little root heap)
		scanf("%c%d", &ch, &freq);		//一开始没用字符%c 导致 WA 
		getchar();
		node temp(freq);
		q.push(temp);
	}
	while(q.size() > 1){
		int left_pos = 0, right_pos = 0;
		if (q.top().leaf == true){
			arr[index] = q.top();	//the smallest as left child
			left_pos = index++;
		}	
		else
			left_pos = q.top().pos;	//若已经存在，则把已存在结点的字符对应下标拿出来 
		int Lfreq = q.top().freq;
		q.pop();
		
		
		if (q.top().leaf == true){
			arr[index] = q.top();	//the second smallest as right child
			right_pos = index++;
		}
		else
			right_pos = q.top().pos;	
		int Rfreq = q.top().freq;
		q.pop();
		
		int sum = Lfreq + Rfreq;	//their sum becomes parent 
		node P(sum, index, false);
		arr[left_pos].parent = arr[right_pos].parent = index;	//通过下标去修改其parent 
		
		
		arr[index++] = P;
		q.push(P);				//sum back into the priority_queue
	}
	arr[index] = q.top();		
	arr[index].pos = index;		//记住把根节点的情况补全 
	
	int result = 0;
	for (int i = 0; i <= index; i++){
		if (arr[i].leaf == true){
			int lv = 0;
			int ptr = arr[i].parent;
			while (ptr > 0){
				lv++;
				ptr = arr[ptr].parent;
			}
			result += (lv * arr[i].freq);
		}
	}
	
	printf("%d\n", result);
	return 0;
}