HDU5845 Best Division

递归写法，好久不写很容易就gg了...

dp[i]=max(dp[j])+1,并且s[i]XORs[j]<=x 

01字典树优化一下转移。

 #include <bits/stdc++.h>

 #define ll long long
 #define ull unsigned long long
 #define st first
 #define nd second
 #define pii pair<int, int>
 #define pil pair<int, ll>
 #define pli pair<ll, int>
 #define pll pair<ll, ll>
 #define tiii tuple<int, int, int>
 #define pw(x) ((1LL)<<(x))
 #define lson l, m, rt<<1
 #define rson m+1, r, rt<<1|1
 #define FIN freopen("A.in","r",stdin);
 #define FOUT freopen("A.out","w",stdout);
 using namespace std;
 /***********/
 template <class T>
 bool scan (T &ret) {
     char c;
     int sgn;
     if (c = getchar(), c == EOF) return ; //EOF
     while (c != '-' && (c < '' || c > '') ) c = getchar();
     sgn = (c == '-') ? - : ;
     ret = (c == '-') ?  : (c - '');
     while (c = getchar(), c >= '' && c <= '') ret = ret *  + (c - '');
     ret *= sgn;
     return ;
 }
 template<typename N,typename PN>inline N flo(N a,PN b){return a>=?a/b:-((-a-)/b)-;}
 template<typename N,typename PN>inline N cei(N a,PN b){return a>?(a-)/b+:-(-a/b);}
 template<typename T>inline int sgn(T a) {return a>?:(a<?-:);}
 template <class T1, class T2>
 bool gmax(T1 &a, const T2 &b) { return a < b? a = b, :;}
 template <class T1, class T2>
 bool gmin(T1 &a, const T2 &b) { return a > b? a = b, :;}
 template <class T> inline T lowbit(T x) {return x&(-x);}

 template<class T1, class T2>
 ostream& operator <<(ostream &out, pair<T1, T2> p) {
     return out << "(" << p.st << ", " << p.nd << ")";
 }
 template<class A, class B, class C>
 ostream& operator <<(ostream &out, tuple<A, B, C> t) {
     return out << "(" << get<>(t) << ", " << get<>(t) << ", " << get<>(t) << ")";
 }
 template<class T>
 ostream& operator <<(ostream &out, vector<T> vec) {
     out << "("; for(auto &x: vec) out << x << ", "; return out << ")";
 }
 void testTle(int &a){
     while() a = a*(long long)a%;
 }
 const int inf = 0x3f3f3f3f;
 const long long INF = 1e17;
 const long long mod = ;
 const double eps = 1e-;
 const int N = 1e5+;
 /***********/

 int a[N], X;
 struct Tire{
     int tot, node[N][], val[N], dp[N];
     int newnode(){
         ++tot;
         node[tot][] = node[tot][] = val[tot] = ;
         dp[tot] = -1e9;
         return tot;
     }
     void init(){
         tot = ;
         newnode();
     }
     void pushup(int rt){
         val[rt] = ;
         dp[rt] = -1e9;
         if(node[rt][]&&val[ node[rt][] ]) {
             gmax(dp[rt], dp[ node[rt][] ]);
             val[rt] += val[ node[rt][] ];
         }
         if(node[rt][]&&val[ node[rt][] ]) {
             gmax(dp[rt], dp[ node[rt][] ]);
             val[rt] += val[ node[rt][] ];
         }
     }
     void update(int x, int d, int v, int now = , int dep = ){
         if(dep == -){
             val[now] += d;
             if(val[now]) gmax(dp[now], v);
             else dp[now] = -1e9;
             return ;
         }
         int t = &(x>>dep);
         if(!node[now][t]) node[now][t] = newnode();
         update(x, d, v, node[now][t], dep-);
         pushup(now);
     }
     int query(int x, int now = , int dep = ){
         if(dep == -) return dp[now];
         int t1 = &(X>>dep), t2 = &(x>>dep);
         int ret = -1e9;
         if(t1){
             if(node[now][t2]) gmax(ret, dp[ node[now][t2] ]);
             if(node[now][t2^]) gmax(ret, query(x, node[now][t2^], dep-));
         }
         else if(node[now][t2]) gmax(ret, query(x, node[now][t2], dep-));
         return ret;
     }
 }T;
 int f[N];
 int main(){
     int t; scanf("%d", &t);
     while(t--){
         int n, L, p, q, i;
         scanf("%d%d%d", &n, &X, &L);
         scanf("%d%d%d", a+, &p, &q);
         for(i = ; i <= n; i++)
             a[i] = (a[i-]*(ll)p+q)%268435456LL;
         for(int i = ; i <= n; i++)
             a[i] = a[i]^a[i-];
         T.init();
         T.update(a[], , f[]);
         for(i = ; i <= n&&i <= L; i++){
             f[i] = T.query(a[i])+;
             T.update(a[i], , f[i]);
         }

         for( ; i <= n; i++){
             T.update(a[i-L-], -, f[i-L-]);
             f[i] = T.query(a[i])+;
             T.update(a[i], , f[i]);
         }
         printf("%d\n", max(f[n], ));
     }
     return ;
 }