BNU 4356 ——A Simple But Difficult Problem——————【快速幂、模运算】

A Simple But Difficult Problem

Time Limit: 5000ms

Memory Limit: 65536KB

64-bit integer IO format: %lld      Java class name: Main

Prev 

Submit Status Statistics Discuss

 Next

Type: 

None

 

  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!

 计算前n个正整数的k次幂之和：

结果可能会非常非常大，输出结果的最后5位即可。

 

Input

输入数据有多组。每组数据一行，每行包括两个整数n和k (1<=n<=1,000,000,000,1<=k<=1000)。

输入数据以-1 -1 结束。

 

Output

对每一组输入数据，输出单独一行，包括一个整数，给出对应的答案。

 

Sample Input

100 1
100 2 
-1 -1

Sample Output

05050
38350

Source

第九届北京师范大学程序设计竞赛决赛

 

 

解题思路：快速幂解决超时问题。

 

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<math.h>
#include<string>
#include<iostream>
#include<queue>
#include<vector>
#include<set>
using namespace std;
typedef long long LL;
#define mid (L+R)/2
#define lson rt*2,L,mid
#define rson rt*2+1,mid+1,R
const int INF = 0x3f3f3f3f;
const int maxn = 1e5 + 300;
const int mod = 1e5;
LL qpowmod(LL n,LL k){
    LL ret = 1;
    while(k){
        if(k&1)
            ret = (ret*n) % mod;
        k = k>>1;
        n = n*n % mod;
    }
    return ret;
}
int main(){
    LL n, k;
    while(scanf("%lld%lld",&n,&k)!=EOF){
        if(n==-1 && k==-1) break;
        LL sum = 0;
        LL mo = n%mod, quotient = n/mod;
        if(quotient){
            for(LL i = 1;i <= mod; i++){
                sum = (sum + qpowmod(i,k)) % mod;
            }
            sum = (sum*quotient) % mod;
        }
        for(LL i = 1; i <= mo; i++){
            sum = (sum + qpowmod(i,k))%mod;
        }
        printf("%05lld\n",sum);
    }
    return 0;
}