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

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!

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

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

Input

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

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

Output

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

Sample Input

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;

}