lightoj 1085 树状数组+dp

最新推荐文章于 2018-09-16 17:11:34 发布

NineFailure

最新推荐文章于 2018-09-16 17:11:34 发布

阅读量375

点赞数

CC 4.0 BY-SA版权

分类专栏： ACM练习动态规划树状数组

本文链接：https://blog.youkuaiyun.com/NineFailure/article/details/52896151

ACM练习同时被 3 个专栏收录

312 篇文章

订阅专栏

动态规划

88 篇文章

订阅专栏

树状数组

7 篇文章

订阅专栏

本文介绍了一个关于二进制数的操作问题，包括位翻转查询，并讨论了如何利用树状数组优化动态规划算法解决该问题。通过具体代码示例展示了算法实现细节。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Description
Given a binary number, we are about to do some operations on the number. Two types of operations can be here.

‘I i j’ which means invert the bit from i to j (inclusive)
‘Q i’ answer whether the ith bit is 0 or 1

The MSB (most significant bit) is the first bit (i.e. i=1). The binary number can contain leading zeroes.

Input
Input starts with an integer T (≤ 10), denoting the number of test cases.

Each case starts with a line containing a binary integer having length n (1 ≤ n ≤ 105). The next line will contain an integer q (1 ≤ q ≤ 50000) denoting the number of queries. Each query will be either in the form ‘I i j’ where i, j are integers and 1 ≤ i ≤ j ≤ n. Or the query will be in the form ‘Q i’ where i is an integer and 1 ≤ i ≤ n.

Output
For each case, print the case number in a single line. Then for each query ‘Q i’ you have to print 1 or 0 depending on the ith bit.

Sample Input
2
0011001100
6
I 1 10
I 2 7Description
An increasing subsequence from a sequence A1, A2 … An is defined by Ai1, Ai2 … Aik, where the following properties hold

i1 < i2 < i3 < … < ik and
Ai1 < Ai2 < Ai3 < … < Aik

Now you are given a sequence, you have to find the number of all possible increasing subsequences.

Input
Input starts with an integer T (≤ 10), denoting the number of test cases.

Each case contains an integer n (1 ≤ n ≤ 105) denoting the number of elements in the initial sequence. The next line will contain n integers separated by spaces, denoting the elements of the sequence. Each of these integers will be fit into a 32 bit signed integer.

Output
For each case of input, print the case number and the number of possible increasing subsequences modulo 1000000007.

Sample Input
3
3
1 1 2
5
1 2 1000 1000 1001
3
1 10 11
Sample Output
Case 1: 5
Case 2: 23
Case 3: 7

这个题，讲道理单纯作为一个dp来讲
弱智的一匹
但是学长们把它放在树状数组专题测试里面
这就很诡异了
想了一会发现没啥思路….
看看剩下其他俩题卧槽都不会…这就很尴尬了….
然后按照寻常dp的思路想了想发现了一点东西….
按照最垃圾的那种dp做法这个题应该是每一个都从前面转移，
从前向后的一个过程…..
但是10^5的数据量n^2不炸就不对了….
然后就突然看到了这个求和的过程…
既然是求和的一个过程那么就很好理解了….
用把自己转移到其他可达状态的那种写法
nlgn勉强写出来了….
然后还有一点是xjb写的，比如那个排序为什么一样大是大序号在前我也不知道
一发不过xjb改反正就这么写完就是能过….
等想明白了补充….

#include<iostream>
#include<memory.h>
#include<algorithm>
#include<cstdio>
#include<string>
using namespace std;
int lowbit(int x) 
{
    return x&-x;
}
int ga[100001];
int c[100001];
int n, m;
int sss[100000];
int gs(int x)
{
    int q = 0;
    for (int y = x;y > 0;y -= lowbit(y))q += c[y],q%=1000000007;
    return q;
}
void gengxin(int xiabiao, int zhi)
{
    for (int q = xiabiao;q <= n;q += lowbit(q))
    {
        c[q] += zhi;
        c[q] %= 1000000007;
        //if (c[q] < 0)c[q] = 0;
    }
}
int asasa(int qqw, int wwe)
{
    if (ga[qqw] != ga[wwe])return ga[qqw] < ga[wwe];
    else return qqw > wwe;
}
int main()
{
    int T;
    cin >> T;
    int u = 0;
    while (T--)
    {
        memset(c, 0, sizeof(c));
        memset(sss, 0, sizeof(sss));
        cin >> n;
        for (int a = 1;a <= n;a++)scanf("%d", &ga[a]), sss[a]=a;
        sort(sss + 1, sss + 1 + n,asasa);
        for (int a = 1;a <= n;a++)gengxin(sss[a], gs(sss[a])+1);
        printf("Case %d: %d\n", ++u, gs(n));
    }
    return 0;
}