CodeVs 2245 股票趋势 （二维线段树 zkw）

2245 股票趋势

10.30
时间限制: 2 s
空间限制: 128000 KB

题目描述 Description
彭先生任职于证券公司，是一位股票分析师。公司经理认为目前的股票分析软件仍可再改进，希望彭先生再设计一套更准确的软件。近日來，彭先生埋头钻研，他发现过去的研究结果，有人提到，如果能在历史资料中，找到与近期股票走势相近的样型，即可使用此历史样型的交易策略，做为近期的买卖策略。为了验证这样的讲法是否正确，彭先生从股票历史资料抽出一些特征资料，并以大写英文字母A~Z 代表特征资料，因此股票资料变成一串的英文字母序列。判断近期股票资料与某一段历史资料是否相近，就变成判断二串字母序列( 长度不一定相等) 的相似度，亦即找出兩者的最长共同子序列(LCS，longest common subsequence) 。

在计算二串股票资料序列的相似度时，还有一个限制，兩个相似点( 相同字母) 的前后间距不能太远，否则相似度会被扭曲。发现了这个特性后，彭先生将此问题正式定义为「有间距限制的最长共同子序列」(GLCS, gapped longest common subsequence)问题。

假设第一个序列称为α，第二个序列称为β。例如，α =“ACBDCAA”，β=“ADDBCDBAC” 。兩者在无间距限制的情形下，其 LCS 可为“ADCA” ， “ABCA” ，或“ACBC” ，长度为4。假设间距限制如下：

A 2, B 0, C 3, D 0

上述间距之意义为，如果字母A 被选入LCS 中，则与其前一个被选入的字母之间，在α序列最多只能有2 个未被选入的字母，在β序列亦同。α与β在上述间距限制的情形，GLCS 可为“ACA” 或“ACC” ，长度为3。

对于无间距限制的情形，可将每个字母的间距视为无限大。本题的答案只要输出GLCS 的长度即可。

输入描述 Input Description
共分成二部分。第一部分，第一行为α序列，第二行为β序列，兩者都是大写英文字母A~Z 的序列，每个序列长度至少为 1，最长为 800。第二部分自第三行起，第三行有一个数值 k，代表以下有 k 组测试资料(1 ≤ k≤ 5) ，每一组测试资料为一行，每一行有多个( 可能零个) 字母间距限制，每个限制的第一个为英文字母，第二个为间距数值( 数值介于0 与400 之间)；英文字母不一定按照顺序，也不一定每个字母都会出现，未出现的字母间距可视为无限大。每一行字母间距限制的最后一个符号为$ ，代表该行( 该组) 的资料结束。每一行的字母间距限制情形，相邻兩项资料之间均有一个空白隔开。

输出描述 Output Description
对于每一组测试资料，输出它的 GLCS 长度。输出这 k 个值于一行，且相邻兩个整数之间以一个空白隔开。

样例输入 Sample Input
样例1：

ACBDCAA

ADDBCDBAC

2

$

A 2 B 0 C 3 D 0 $

样例2：

ACBDCAA

ADDBCDBAC

1

C 4 A 6 $

样例输出 Sample Output
样例1：

4 3

样例2：

4

数据范围及提示 Data Size & Hint
TW一百学年度全国高级中学咨询学科能力竞赛决赛5

思路：
dp[i][j]表示A串到i，B串到j的最大值（i，j必须选）
转移的时候dp[i][j] = max( dp[k][l] )( i-len[A[i]]-1 <= k < i, j-len[B[j]]-1 <= l < j ) + 1
当时自己想了个n^2*26的裸dp，结果挂掉了，dp的转移来源没法贪心呀呀呀~~~无可奈何数据结构

先粘一个普通二维线段树

#include<stdio.h>
#include<cstring>
#include<algorithm>
using namespace std;

const int INF=0x3f3f3f3f;

struct node
{
    int sum;
    node *ls,*rs;
    void update()
    {
        sum=max(ls->sum,rs->sum);
    }
}pool1[8000010],*tail=pool1;

struct Node
{
    node *root;
    Node *ls,*rs;
}pool[8000010],*head=pool,*root;

int n,m,T,ans=0;
int f[3010][3010],src[110];
char A[100010],B[100010],tmp[10];

void init()
{
    ans=0;
    tail=pool1,head=pool;
    memset(f,0,sizeof(f));
    memset(src,INF,sizeof(src));
}

node *built(int lf,int rg)
{
    node *nd=++tail;
    if(lf==rg)
    {
        nd->sum=0;
        nd->ls=nd->rs=0;
        return nd;
    }
    int mid=(lf+rg)>>1;
    nd->ls=built(lf,mid);
    nd->rs=built(mid+1,rg);
    nd->update();
    return nd;
}

Node *build(int lf,int rg)
{
    Node *nd=++head;
    nd->root=built(1,m);
    if(lf==rg)
    {
        nd->ls=nd->rs=0;
        return nd;
    }
    int mid=(lf+rg)>>1;
    nd->ls=build(lf,mid);
    nd->rs=build(mid+1,rg);
    return nd;
}

void modify(node *nd,int lf,int rg,int pos,int delta)
{
    if(lf==rg)
    {
        nd->sum=max(nd->sum,delta);
        return ;
    }
    int mid=(lf+rg)>>1;
    if(pos<=mid) modify(nd->ls,lf,mid,pos,delta);
    else modify(nd->rs,mid+1,rg,pos,delta);
    nd->update();
}

void modify(Node *nd,int lf,int rg,int pos1,int pos2,int delta)
{
    modify(nd->root,1,m,pos2,delta);
    if(lf==rg) return ;
    int mid=(lf+rg)>>1;
    if(pos1<=mid) modify(nd->ls,lf,mid,pos1,pos2,delta);
    else modify(nd->rs,mid+1,rg,pos1,pos2,delta);
}

int query(node *nd,int lf,int rg,int L,int R)
{
    if(L>R) return 0;
    if(L<=lf && rg<=R)
         return nd->sum;
    int mid=(lf+rg)>>1,rt=0;
    if(L<=mid) rt=max(rt,query(nd->ls,lf,mid,L,R));
    if(R>mid) rt=max(rt,query(nd->rs,mid+1,rg,L,R));
    return rt;
}

int query(Node *nd,int lf,int rg,int L1,int R1,int L2,int R2)
{
    if(L1>R1) return 0;
    if(L1<=lf && rg<=R1)
        return query(nd->root,1,m,L2,R2);
    int mid=(lf+rg)>>1,rt=0;
    if(L1<=mid) rt=max(rt,query(nd->ls,lf,mid,L1,R1,L2,R2));
    if(R1>mid) rt=max(rt,query(nd->rs,mid+1,rg,L1,R1,L2,R2));
    return rt;
}

int main()
{
    freopen("glsc.in","r",stdin);
    freopen("glsc.out","w",stdout);
    scanf("%s",A+1);
    scanf("%s",B+1);
    n=strlen(A+1),m=strlen(B+1);
    scanf("%d",&T);
    while(T--)
    {
        init();
        root=build(1,n);
        while(scanf("%s",tmp) && tmp[0]!='$')
        {
            int x;
            scanf("%d",&x);
            src[tmp[0]-'A']=x;
        }
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)
                if(A[i]==B[j])
                {
                    int R1=i-1,L1=max(1,i-src[A[i]-'A']-1);
                    int R2=j-1,L2=max(1,j-src[A[i]-'A']-1);
                //  if(i==3 && j==4) printf("%d\n",query(root,1,n,1,1,1,1));    
                    f[i][j]=query(root,1,n,L1,R1,L2,R2)+1;
                    modify(root,1,n,i,j,f[i][j]);
                //  printf("f[%d][%d] : %d\n",i,j,f[i][j]);
                }else f[i][j]=0;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)
                ans=max(ans,f[i][j]);
        printf("%d ",ans);
    }
    return 0;
}

再学习一个二维线段树（zkw）

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#define LL long long
#define N 1010
using namespace std;
#define Max(a,b) if (a < b) a = b

char s1[N], s2[N];
int a[N], b[N];
int lena, lenb, N1, N2;
int d[30];
int c[N << 1][N << 1];

inline int query(int lf1, int rg1, int lf2, int rg2) {
    int ret = 0;
    lf2 += N2-1; rg2 += N2+1;
    for(lf1 += N1-1, rg1 += N1+1; lf1^rg1^1; lf1 >>= 1, rg1 >>= 1) {
        if(~lf1 & 1)
            for (int l = lf2, r = rg2; l^r^1; l >>= 1, r >>= 1) {
                if(~l & 1) Max(ret, c[lf1^1][l^1]);
                if( r & 1) Max(ret, c[lf1^1][r^1]);
            }
        if( rg1 & 1)
            for(int l = lf2, r = rg2; l^r^1; l >>= 1, r >>= 1) {
                if(~l & 1) Max(ret, c[rg1^1][l^1]);
                if( r & 1) Max(ret, c[rg1^1][r^1]);
            }
    }
    return ret;
}

inline void modify(int lf, int rg, int val) {
    rg += N2;
    for(lf += N1; lf; lf >>= 1)
        for(int r = rg; r; r >>= 1)
            Max(c[lf][r], val);
}

void work() {
    memset(c, 0, sizeof c);
    for(int i=1; i<=lena; i++){
        for(int j=1; j<=lenb; j++){
            if(a[i] == b[j]) {
                if( d[a[i]] != -1 ) 
                    modify(i, j, query(i-d[a[i]]-1, i-1, j-d[a[i]]-1, j-1) + 1);
                else 
                    modify(i, j, query(1, i-1, 1, j-1) + 1);
            }
        }
    }
}

int main() {
    freopen ("glsc.in", "r", stdin);
    freopen ("glsc.out", "w", stdout);
    scanf("%s%s", s1+1, s2+1);
    int T; scanf("%d", &T);
    lena = strlen( s1 + 1 ); lenb = strlen( s2 + 1 );
    for(int i=1; i<=lena; i++) a[i] = s1[i] - 'A';
    for(int i=1; i<=lenb; i++) b[i] = s2[i] - 'A';
    for(N1=1; N1<lena+2; N1<<=1);  //
    for(N2=1; N2<lenb+2; N2<<=1);  
    while ( T-- ) {
        memset(d, -1, sizeof(d));
        char ch; scanf("%c", &ch);
        while (ch != '$') {
            scanf("%d", &d[ch - 'A']);
            scanf("%c", &ch);
        }
        work();
        printf("%d ",query(1, lena, 1, lenb));
    }
    return 0;
}