【8.15校内测试】【队列】【manacher】

dp？？不能确定转移状态。考虑用优先队列储存最优决策点，可是发现当前选择最优不能保证最后最优，在后面可以将之前用过的替换过来。

比如数据：

3 5

4 6

只储存a[i]来决策不能延展到后面的状态，因此每次选择过后把b[i]加入队列，下次选择最优时如果选择到了b[i]，则表示用之前选择过的来替换到当前状态。

这里我开了两个优先队列。

 #include<iostream>
 #include<cstdio>
 #include<queue>
 #define ll long long
 #define RG register
 using namespace std;

 int n, a[], b[];

 priority_queue < int, vector < int > , greater < int > > q1, q2;

 int main ( ) {
     freopen ( "buy.in", "r", stdin );
     freopen ( "buy.out", "w", stdout );
     scanf ( "%d", &n );
     for ( RG int i = ; i <= n; i ++ )
         scanf ( "%d", &a[i] );
     for ( RG int i = ; i <= n; i ++ )
         scanf ( "%d", &b[i] );
     ll ans = ;
     for ( RG int i = ; i <= n; i ++ ) {
         q1.push ( a[i] );
         int r1 = , r2 = ;
         if ( !q1.empty ( ) ) {
             int x = q1.top ( );
             if ( b[i] > x ) r1 = b[i] - x;
         }
         if ( !q2.empty ( ) ) {
             int x = q2.top ( );
             if ( b[i] > x ) r2 = b[i] - x;
         }
         if ( r1 >= r2 && r1 ) ans += r1, q1.pop ( ), q2.push ( b[i] );
         else if ( r2 > r1 && r2 ) ans += r2, q2.pop ( ), q2.push ( b[i] );
     }
     printf ( "%I64d", ans );
     return ;
 }

记录前缀和，可以发现，从某一个点为起点时，向后延展出去的长度中一定有i到i+s这一段，所以用前缀和最大值建一棵线段树，每次查找i+s-1到i+e-1段的最大值，减去i-1的前缀和比较答案即可。

 #include<iostream>
 #include<cstdio>
 #define ll long long
 using namespace std;

 int n, s, e, a[];
 ll pre[], TR[];

 void update ( int nd ) {
     TR[nd] = max ( TR[nd << ], TR[nd <<  | ] );
 }

 void build ( int nd, int l, int r ) {
     if ( l == r ) {
         TR[nd] = pre[l];
         return ;
     }
     int mid = ( l + r ) >> ;
     build ( nd << , l, mid );
     build ( nd <<  | , mid + , r );
     update ( nd );
 }

 ll query ( int nd, int l, int r, int L, int R ) {
     if ( l >= L && r <= R ) return TR[nd];
     int mid = ( l + r ) >> ;
     ll ans = -1e9;
     if ( L <= mid ) ans = max ( ans, query ( nd << , l, mid, L, R ) );
     if ( R > mid ) ans = max ( ans, query ( nd <<  | , mid + , r, L, R ) );
     return ans;
 }

 int main ( ) {
     freopen ( "invest.in", "r", stdin );
     freopen ( "invest.out", "w", stdout );
     scanf ( "%d%d%d", &n, &s, &e );
     for ( int i = ; i <= n; i ++ ) {
         scanf ( "%d", &a[i] );
         pre[i] = pre[i-] + a[i];
     }
     build ( , , n );
     ll ans = ;
     for ( int i = ; i <= n; i ++ ) {
         if ( i + s -  > n ) break;
         ll x = query ( , , n, i + s - , i + e -  );
         ans = max ( x - pre[i-], ans );
     }
     printf ( "%I64d", ans );
     return ;
 }

关键时候manacher忘了怎么写！！先manacher一遍处理出以每个点为中心点的最长回文串长度，一定是奇数。开桶记录每个长度出现次数，从大到小枚举长度l，每次把l-2的次数加上l的次数，因为l的长度满足回文串l-2一定满足（同一中心点，注意k要开long long！

 #include<iostream>
 #include<cstdio>
 #define ll long long
 #define mod 19930726
 using namespace std;

 ll max_r[];
 int n;
 ll k;
 ll ans = , flag[];

 char M[], a[];

 inline ll min ( ll a, int b ) {
     return a < b ? a : b;
 }

 ll mi ( ll a, ll b ) {
     ll an = ;
     for ( ; b; b >>= , a = a * a % mod )
         if ( b &  ) an = an * a % mod;
     return an;
 }

 void manacher ( ) {
     M[] = '@';
     for ( int i = ; i <= n; i ++ ) {
         M[ * i - ] = '#';
         M[ * i] = a[i];
     }
     M[ * n + ] = '#'; M[ * n + ] = '$';
     int center = ; ll mx = ;
     int side = n *  + ;
     for ( int i = ; i <= n *  + ; i ++ ) {
         if ( mx > i ) max_r[i] = min ( mx - (ll)i, max_r[center *  - i] );
         else max_r[i] = ;
         while ( M[max_r[i]+i] == M[i-max_r[i]] ) max_r[i] ++;
         if ( mx < i + max_r[i] ) {
             mx = i + max_r[i]; center = i;
         }
     }
 }

 int main ( ) {
     freopen ( "rehearse.in", "r", stdin );
     freopen ( "rehearse.out", "w", stdout );
     scanf ( "%d%I64d\n", &n, &k );
     scanf ( "%s", a +  );
     manacher ( );
     ll MA = ;
     for ( int i = ; i <= n; i ++ ) {
         max_r[i*] --;
         flag[max_r[i*]] ++;
         MA = max ( MA, max_r[i*] );
     }
     ll pos = MA;
     while ( k >  ) {
         ans = ( ans * mi ( pos, min ( flag[pos], k ) ) ) % mod;
         flag[pos-] += flag[pos];
         k -= flag[pos];
         pos = pos - ;
     }
     printf ( "%I64d", ans );
     return ;
 }