Increasing Speed Limits
来源:互联网 发布:腾讯收购知乎了吗 编辑:程序博客网 时间:2024/06/04 21:59
Time Remaining: You may resubmit this multiple times within the remaining time-frame. Only your last submission will count. |
Problem
You were driving along a highway when you got caught by the road police for speeding. It turns out that they've been following you, and they were amazed by the fact that you were accelerating the whole time without using the brakes! And now you desperately need an excuse to explain that.
You've decided that it would be reasonable to say "all the speed limit signs I saw were in increasing order, that's why I've been accelerating". The police officer laughs in reply, and tells you all the signs that are placed along the segment of highway you drove, and says that's unlikely that you were so lucky just to see some part of these signs that were in increasing order.
Now you need to estimate that likelihood, or, in other words, find out how many different subsequences of the given sequence are strictly increasing. The empty subsequence does not count since that would imply you didn't look at any speed limits signs at all!
For example, (1, 2, 5) is an increasing subsequence of (1, 4, 2, 3, 5, 5), and we count it twice because there are two ways to select (1, 2, 5) from the list.
Input
The first line of input gives the number of cases, N. N test cases follow. The first line of each case contains n, m, X, Y and Z each separated by a space. n will be the length of the sequence of speed limits. m will be the length of the generating array A. The next m lines will contain the m elements of A, one integer per line (from A[0] to A[m-1]).
Using A, X, Y and Z, the following pseudocode will print the speed limit sequence in order. mod indicates the remainder operation.
for i = 0 to n-1
print A[i mod m]
A[i mod m] = (X * A[i mod m] + Y * (i + 1)) mod Z
Note: The way that the input is generated has nothing to do with the intended solution and exists solely to keep the size of the input files low.
Output
For each test case you should output one line containing "Case #T: S" (quotes for clarity) where T is the number of the test case and S is the number of non-empty increasing subsequences mod 1 000 000 007.
Limits
1 ≤ N ≤ 20
1 ≤ m ≤ 100
0 ≤ X ≤ 109
0 ≤ Y ≤ 109
1 ≤ Z ≤ 109
0 ≤ A[i] < Z
Small dataset
1 ≤ m ≤ n ≤ 1000
Large dataset
1 ≤ m ≤ n ≤ 500 000
Sample
Input | Output |
2 | Case #1: 15 |
没赶上Round1A 郁闷。
Round1C Solve1和2,3的large不会做,菜。Rank好像是60多,能过。
赛后学习了下,也不算太难。
本来DP方程是这样的
for(i = 0; i < n; ++i) {
for(j = 0; j < i; ++j) {
if(A[j] < A[i]) {
dp[i] += dp[j];
}
}
}
如果对A排序并且离散化,则变成了
for(i=0; i < n; ++i) {
for(j = 0; j < A[i]; ++j) {
dp[A[i]] += dp[j];
}
}
大家注意看,内循环其实是一个区间求和。那么对于这种求和,线段树只可以做到NlogN的。
记得以前写过一道题的解题报告,是类似的。
pku1769 点树解决块查询点操作
下面是代码:(solve2函数是一个n^2的DP,偶水small input用的)
#include <stdio.h>
#include <cassert>
#include <map>
#include <algorithm>
using namespace std;
const int M = 100;
const int N = 500010;
const int MOD = 1000000007;
typedef long long LL;
int n, m, X, Y, Z;
int A[N], S[N];
int st[1048576];
int upperbound = 524288;
int dp[N];
void generate() {
int i;
for(i = 0; i < n; ++i) {
S[i] = A[i%m];
A[i%m] = ((LL)X*A[i%m]+(LL)Y*(i+1))%Z;
}
for(i = 0; i < n; ++i) {
A[i] = S[i];
}
}
int get(int x, int y) { // 左闭右开
x += upperbound, y += upperbound;
int ans = 0;
while(x + 1 < y) {
if(x&1) { // x是右子树
ans = (ans + st[x]) % MOD;
x++;
}
if(y&1) { // y是右子树
y--;
ans = (ans + st[y]) % MOD;
}
x >>= 1;
y >>= 1;
}
if(x < y)
ans = (ans + st[x]) % MOD;
return ans;
}
void ins(int x, int a) {
x += upperbound;
while(x > 0) {
st[x] = (st[x] + a) % MOD;
x >>= 1;
}
}
void solve() {
memset(st, 0, sizeof(st));
sort(S, S + n);
map<int, int> mm;
int i, j = 0, ans = 0;
for(i = 0; i < n; ++i) {
if(!mm.count(S[i])) {
mm[S[i]] = ++j;
}
}
ins(0, 1);
for(i = 0; i < n; ++i) {
A[i] = mm[A[i]];
int sum = get(0, A[i]);
ans = (ans + sum) % MOD;
ins(A[i], sum);
}
printf("%d/n", ans);
}
void solve2() {
int i, j, k;
for(i = 0; i < n; ++i) dp[i] = 1;
for(i = 1; i < n; ++i) {
for(j = 0; j < i; ++j) {
if(S[j] < S[i]) {
dp[i] += dp[j];
dp[i] %= MOD;
}
}
}
LL sum = 0;
for(i = 0; i < n; ++i) {
sum += dp[i];
sum %= MOD;
}
printf("%I64d/n", sum);
}
int main()
{
// freopen("C-large.in", "r", stdin);
// freopen("C-large.txt", "w", stdout);
int ntc, i, j, k, tc=0;
scanf("%d", &ntc);
while(ntc--) {
printf("Case #%d: ", ++tc);
scanf("%d%d%d%d%d", &n, &m, &X, &Y, &Z);
for(i = 0; i < m; ++i) scanf("%d", A+i);
generate();
// solve2();
solve();
}
return 0;
}
文章来自:http://www.cppblog.com/sicheng/archive/2008/08/02/57824.html
- Increasing Speed Limits
- Increasing Speed Limits
- hdu 3030 Increasing Speed Limits
- hdu 3030 Increasing Speed Limits
- HDU - 3030 Increasing Speed Limits
- 【Codejam2008_Round1C】C:Increasing Speed Limits
- HDU 3030 Increasing Speed Limits 树状数组
- hdu 3030 Increasing Speed Limits 树状数组
- [树状数组+上升子序列] HDU 3030 Increasing Speed Limits
- hdu 3030 Increasing Speed Limits(树状数组求最长上升子序列)
- limits
- speed
- hard limits
- std::limits
- limits.conf
- limits.h
- limits.h
- limits.h
- 各种消息框的类
- 静态页面生成原理及实际应用技巧
- POJ1088
- Links of 2008/10/05
- JFrame窗口关闭时,进行再次确认的实现
- Increasing Speed Limits
- 某A的工口游戏创作者体验记(上)
- 某A的工口游戏创作者体验记(下)
- 网络字节序与主机字节序
- MD5算法研究
- java中判断socket网络远端是否断开连接
- MD5加密(2)
- ACM-Easy Problem-Where is wrong?
- C++ 运算符优先级列表