poj 3070-Fibonacci-矩阵幂乘

Fibonacci

Time Limit: 1000ms

Memory Limit: 65536KB

This problem will be judged on PKU. Original ID:  3070
64-bit integer IO format:  %lld      Java class name:  Main

Prev  Submit  Status  Statistics  Discuss  Next

Font Size:  +   -

Type: 

  None

 Graph Theory

      2-SAT

     Articulation/Bridge/Biconnected Component

     Cycles/Topological Sorting/Strongly Connected Component

     Shortest Path

          Bellman Ford

         Dijkstra/Floyd Warshall

     Euler Trail/Circuit

     Heavy-Light Decomposition

     Minimum Spanning Tree

     Stable Marriage Problem

     Trees

      Directed Minimum Spanning Tree

      Flow/Matching

         Graph Matching

             Bipartite Matching

             Hopcroft–Karp Bipartite Matching

             Weighted Bipartite Matching/Hungarian Algorithm

         Flow

              Max Flow/Min Cut

              Min Cost Max Flow

  DFS-like

     Backtracking with Pruning/Branch and Bound

     Basic Recursion

      IDA* Search

     Parsing/Grammar

     Breadth First Search/Depth First Search

     Advanced Search Techniques

         Binary Search/Bisection

         Ternary Search

 Geometry

      Basic Geometry

     Computational Geometry

     Convex Hull

      Pick's Theorem

 Game Theory

     Green Hackenbush/Colon Principle/Fusion Principle

     Nim

      Sprague-Grundy Number

  Matrix

     Gaussian Elimination

     Matrix Exponentiation

 Data Structures

      Basic Data Structures

      Binary Indexed Tree

      Binary Search Tree

      Hashing

     Orthogonal Range Search

     Range Minimum Query/Lowest Common Ancestor

     Segment Tree/Interval Tree

     Trie Tree

      Sorting

     Disjoint Set

 String

      Aho Corasick

     Knuth-Morris-Pratt

     Suffix Array/Suffix Tree

 Math

      Basic Math

     Big Integer Arithmetic

     Number Theory

          Chinese Remainder Theorem

          Extended Euclid

          Inclusion/Exclusion

          Modular Arithmetic

      Combinatorics

         Group Theory/Burnside's lemma

         Counting

      Probability/Expected Value

  Others

     Tricky

      Hardest

     Unusual

     Brute Force

      Implementation

     Constructive Algorithms

     Two Pointer

      Bitmask

     Beginner

     Discrete Logarithm/Shank's Baby-step Giant-step Algorithm

     Greedy

      Divide and Conquer

  Dynamic Programming

                      Tag it!

In the Fibonacci integer sequence, F₀ = 0, F₁ = 1, and F_n = F_{n − 1} + F_{n − 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, …

An alternative formula for the Fibonacci sequence is

.

Given an integer n, your goal is to compute the last 4 digits of F_n.

Input

The input test file will contain multiple test cases. Each test case consists of a single line containing n (where 0 ≤ n ≤ 1,000,000,000). The end-of-file is denoted by a single line containing the number −1.

Output

For each test case, print the last four digits of F_n. If the last four digits of F_n are all zeros, print ‘0’; otherwise, omit any leading zeros (i.e., print F_n mod 10000).

Sample Input

0
9
999999999
1000000000
-1

Sample Output

0
34
626
6875

代码1：

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

int m[3][3];

int a[100050];
void f() {
	a[0] = 0;
	a[1] = 1;
	for (int i  = 2; i <= 100050; i ++) {
		a[i] = (a[i - 1] + a[i - 2]) % 10000;
	}
}
int main () {
	int n;
	while (scanf("%d", &n) != EOF) {
		if(n == -1) break;
		f();
		printf("%d\n", a[n % 15000]);
	}
	return 0;
}