hdu 5139 (离线处理)

题意:

f(n)=(∏i=1nin?i+1)%1000000007

You are expected to write a program to calculate f(n) when a certain n is given.

思路:

写出前几项,就很容易得出递推式。但是因为n的数据范围是1~10000000,而内存给的小

,所以并不能直接打表(MLE)

采用离线处理——先读完,再一次性输出。

中间采取了一点小技巧,先把所有读入的输入按照n的大小排序,使得处理答案时的时间复杂度为线性的,不然会TLE

code:

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<string>
#include<queue>
#include<map>
#include<set>
#include<cmath>
#include<cstdlib>
using namespace std;

#define INF 0x3f3f3f3f
#define PI acos(-1.0)
#define mem(a, b) memset(a, b, sizeof(a))
#define mod 1000000007
typedef pair<int,int> pii;
typedef long long LL;
//------------------------------
const int maxn = 100005;

//long long f[10000005];
//
//void table(){
//    f[1] = 1;
//    long long sum = 2;
//    for(int i = 2; i <= 10000000; i++){
//        f[i] = (f[i-1] * sum) % mod;
//        sum = sum * (i+1) % mod;
//    }
//}
//int n;
//int main(){
//    table();
//    while(scanf("%d",&n) != EOF){
//        printf("%d\n",(int)f[n]);
//    }
//    return 0;
//}

//应该离线处理

struct node{
    int n, id;
    bool operator < (const node nt) const{
        return n < nt.n;
    }
}ma[maxn];
int cnt = 0;
int ans[maxn];

void solve(){
    long long sum = 1;
    long long tmp = 1;
    int st = 1;

    for(int i = 0; i < cnt; i++){
        for(int j = st; j <= ma[i].n; j++){
            tmp = (tmp * sum) % mod;
            sum = sum * (j+1) % mod;
        }
        st = ma[i].n + 1;
        ans[ma[i].id] = (int)tmp;
    }

    for(int i = 0; i < cnt; i++){
        printf("%d\n",ans[i]);
    }
}
int n;
int main(){
    cnt = 0;
    while(scanf("%d",&n) != EOF){
        ma[cnt].n = n;
        ma[cnt].id = cnt++;
    }
    sort(ma, ma+cnt);
    solve();
    return 0;
}
时间: 2024-11-09 00:40:51

hdu 5139 (离线处理)的相关文章

hdu 5139(离线处理+离散化下标)

Formula Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 1204    Accepted Submission(s): 415 Problem Description f(n)=(∏i=1nin−i+1)%1000000007You are expected to write a program to calculate f(n)

HDU 5139 Formula --离线处理

题意就不说了,求公式. 解法: 稍加推导能够得出 : f(n) = n! * f(n-1) , 即其实是求: ∏(n!)  ,盲目地存下来是不行的,这时候看见条件: 数据组数 <= 100000, 那么我们可以离线做,先把他们存下来,然后再从小到大扫一边, 也就是最多10000000次乘法的复杂度.然后离线输出即可. 代码: #include <iostream> #include <cstdio> #include <cstring> #include <

hdu 5139 Formula (找规律+离线处理)

Formula Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 206    Accepted Submission(s): 83 Problem Description f(n)=(∏i=1nin−i+1)%1000000007You are expected to write a program to calculate f(n) w

HDU 5139数据离线处理

此题可以找到规律f(n) = 1! * 2! *...*n!, 如果直接打表的话,由于n比较大(10000000),所以会超内存,这时候就要用到离线处理数据,就是先把数据存起来,到最后在暴力一遍求解就行了,代码如下 代码一(超内存): 1 #include <stdio.h> 2 3 const long long mod = 1000000007; 4 const int N = 10000007; 5 long long a[N]; 6 7 int main() 8 { 9 a[0] =

hdu 5139 Formula(离线处理)

Formula Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1200    Accepted Submission(s): 415 Problem Description You are expected to write a program to calculate f(n) when a certain n is given.

hdu 5139 Formula

http://acm.hdu.edu.cn/showproblem.php?pid=5139 思路:这道题要先找规律,f(n)=n!*(n-1)!*(n-2)!.....1!;  不能直接打表,而是离线处理,一次性处理出来. 1 #include <cstdio> 2 #include <cstring> 3 #include <map> 4 #include <algorithm> 5 #define ll long long 6 #define mod

HDU 5044 离线LCA算法

昨天写了HDU 3966 ,本来这道题是很好解得,结果我想用离线LCA 耍一把,结果发现离线LCA 没理解透,错了好多遍,终得AC ,这题比起 HDU 3966要简单,因为他不用动态查询.但是我还是错了好多遍  T^T... http://acm.split.hdu.edu.cn/showproblem.php?pid=5044 不多说了  思想不是很清楚的可以看一看我的上一篇博文 HDU 3966 直接贴代码 1 #include<iostream> 2 #include<stdio.

2015 ACM/ICPC Asia Regional Changchun Online HDU - 5441 (离线+并查集)

题目:http://acm.hdu.edu.cn/showproblem.php?pid=5441 题意:给你n,m,k,代表n个城市,m条边,k次查询,每次查询输入一个x,然后让你一个城市对(u,v)满足两点之间每一条边都不超过x,问有多少对 思路:首先我想到的是dfs求出每个查询小于等于他的一个连通块,然后num*(num-1)就是答案,但是时间只有一秒,这个复杂度是5*1e8,超时了(亲身体验了) 然后我们想这个是离线的,我们可不可以由小到大来推,这样前面的贡献到后面就依然能用了,但是我们

HDU 5441 离线处理 + 并查集

题意:给n个节点m条带权值边的无向图.然后q个问题,每次询问点对的数目,点对需要满足的条件是:1)连通:2)其路径的最大权值不能超过询问值. 分析:如果没次询问一次,dfs一次,很可能超时,因此可以用并查集.离线处理,把边按权值排序,把问题按大小排序.然后离线的过程就是不断向图中加边的过程. 比如样例如下: 然后离线处理,排完序后将会是一条一条的加边:问题也排了序,因此是个累加过程... 1 #include <cstdio> 2 #include <iostream> 3 #in