TC SRM 605

Div2  AlienAndSetDiv2   1000 pts

题意：1~2N的数分成２个数组Ａ，Ｂ，并且数组中按增序排列，同时满足|A[i] - B[i]| <= K，问有多少种方法？

分析：从大到小依次决定每个数的放置位置，每次可以放在Ａ或Ｂ中剩余的较高位置，当决定第ｉ个数时，ｉ+K+1，应该是已经匹配了，

那么只剩下ｉ+1~i+K最多Ｋ个数处于未匹配的位置，用一个整数st表示，那么对于第ｉ个数的转移情况，可以放置在某个数组中，

使他处于未匹配状况或者让他匹配．

dp[i][st]表示ｉ个数需要划分，且ｉ+1~i+K+1的未匹配情况用st的表示的方案数．

代码：

 const int MOD = (int)1e9 + ;
 const int maxn = *;
 const int maxm = (<<) + ;
 int dp[maxn][maxm];

 class AlienAndSetDiv2{
         public:
         int K, N, M;
         int dfs(int n, int st) {
             int &res = dp[n][st];
             if (res != -) return res;
             res = ;
             if (st&(<<(K-))) {
                    res = dfs(n-, (st<<) % M);
             } else {
                    if (st == ) {
                        res = dfs(n-, );
                    } else {
                        res = dfs(n-, st<<|);
                        int highBit = K-;
                        while (!((<<highBit) & st)) highBit--;
                        res = (res + dfs(n-, (st^(<<highBit))<<)) % MOD;
                    }
             }
             if (st == )  res = res*%MOD;
             return res;
         }
         int getNumber(int N, int K) {
     memset(dp, -, sizeof dp);
     dp[][] = ;
     for (int i = ; i < maxm; i++) dp[][i] = ;
     M = (<<K);
     this->K = K;
     this->N = N;

     return dfs(*N, );
         }
 };

Div1 AlienAndHamburgers  250pts

题意：ｎ种物品，每种物品有两个值taste[i]，type[i]分别表示其美味值和类型，要求从中选出一些物品，使得类型数＊美味值总和最大．

分析:　按类型排序，将类型相同的物品安排在连续一段考虑，对于第ｉ个物品，如果选中，需要考虑前面一个选中的物品ｊ,　及之前选中的类型总数，

如果ｊ的类型和ｉ的类型不同，那么选中前一个物品ｊ的时候，选中的类型数比当前少１；否则就和当前类型数目一样．

设立状态表示dp[i][x][y] 表示选中第ｉ的时候，选中的类型为ｘ，选择的类型数为ｙ的最大值．

代码：

 typedef long long LL;
 typedef unsigned US;
 typedef pair<int, int> PII;
 typedef map<PII, int> MPS;
 typedef MPS::iterator IT;
 const int maxn = ;
 int dp[maxn][maxn][maxn];
 int vis[];
 bool mark[maxn][maxn][maxn];
 int cnt;
 struct Node {
   int val, t;
   Node() {}
   Node (int val, int t) {
     if (!vis[t]) {
       vis[t] = ++cnt;
     }
     this->t = vis[t];
     this->val = val;
   }
   bool operator < (const Node &o) const {
     return t < o.t;
   }
 } a[maxn];
 class AlienAndHamburgers {
 public:
   int n;
   int dfs(int pos, int x, int y) {
     int &res = dp[pos][x][y];
     if (mark[pos][x][y]) return res;
     mark[pos][x][y] = true;
     res = -inf;
     if (x ==  || y == ) return res;
     for (int i = ; i < pos; i++) {
       int nx = a[i].t;
       int ny = y - !(nx == x);
       int z = dfs(i, nx, ny);
       if (res < (z == -inf ? 1LL * -inf :  (ny ==  ? 1LL * y * a[pos].val : (0LL + z / ny + a[pos].val) * y)))
         res = (z == -inf ? 1LL * -inf :  (ny ==  ? 1LL * y * a[pos].val : (0LL + z / ny + a[pos].val) * y));
     }
     return res;
   }

   int getNumber(vector <int> type, vector <int> taste) {
     // memset(dp, -1, sizeof dp);
     memset(mark, false, sizeof mark);

     cnt = ;
     for (int i = ; i < maxn; i++) {
       for (int j = ; j < maxn; j++) {
         for (int k = ; k < maxn; k++)
           dp[k][i][j] = -inf;
         mark[][i][j] = true;
       }
     }
     dp[][][] = ;

     memset(vis, , sizeof vis);

     n = (int)type.size();

     for (int i = ; i < n;  i++) {
       a[i + ] = Node(taste[i], type[i]);
     }
     a[].t = a[].val = ;
     sort(a + , a + n + );
     int ans = ;
     for (int i = ; i <= n; i++)
       for (int j = ; j <= a[i].t; j++)
         ans = max(ans, dfs(i, a[i].t, j));
     return ans;
   }
 };

Div1 AlienAndSetDiv1    450pts

题意：Div2 1000pts升级版，不同的是题目条件|A[i]-B[i]| <= K 变成了|A[i]-B[i]| >= K.不过分析过程还是差不多的．

分析：同样的从２N 到１按照从大到小的顺序进行安排，从Ａ，Ｂ的高位往下进行放置．由于两个数要相差K以上才能配对，因此当考虑第ｉ个数的时候，

对于尚未配对且满足>=i+K的数此时是可以和剩下的任意数配对的，而i+1～i+K-1之间的数时需要继续等待的，因此此时状态表示变成了dp[i][st][j]，表示

分配剩下的ｉ个数时，>=i+K的个数有ｊ个，ｉ+1~i+K-1之间的状态是st,这样只需要建立状态转移即可．

代码：

 const int maxn =  + ;
 const int maxm = ( << ) + ;
 const int MOD =  ;

 int dp[maxn][maxn][maxm];

 class AlienAndSetDiv1 {
 public:
     int N, K, M;
     int dfs(int n, int m, int st) {
         int &res = dp[n][m][st];
         if (res != -) return res;
         res = ;
         if (K == ) {
             res = dfs(n - , m + , );
             if (m > )
                 res = (res + dfs(n - , m - , )) % MOD;
         } else {
             if (st == ) {
                 if (m == ) {
                     res = dfs(n - , K == , K != );
                 } else {
                     res = dfs(n - , m - , );
                     res = (res + dfs(n - , m + (K == ), K != )) % MOD;
                 }
             } else {
                 if (m == ) {
                     res = dfs(n - , ((st & ( << (K - ))) != ) + (K == ), (st <<  | (K != )) % M);

                 } else {
                     res = dfs(n - , m -  +  ((st & ( << (K - ))) != ), (st << ) % M);
                     res = (res + dfs(n - , m + (K == ) + ((st & ( << (K - ))) != ), (st <<  | (K != )) % M)) % MOD;
                 }
             }
         }
         if (st ==  && m == ) res = res *  % MOD;
         return res;
     }
     int getNumber(int N, int K) {
         memset(dp, -, sizeof dp);
         for (int i = ; i < maxn; i++)
             for (int j = ; j < maxm; j++)
                 dp[][i][j] = ;
         dp[][][] = ;
         M =  << (K - );
         this->N = N;
         this->K = K;
         return dfs( * N, , );
     }
 };

Div1 AlienAndPermutation 1000pts

题意：给定一个数组Ｐ为１～Ｎ数字的排列，最多可以进行Ｋ次操作：每次选取一个区间，将区间中的数替换成该区间内的数的最大值，最后能够得到不同的数组Ｓ．

分析：要解决这个题目首先要发现操作后的数组的性质，

1. S中满足Ｓ[j] = P[i]的位置构成连续序列

2. P[i]和Ｐ[j]的连续序列在S中相对位置不变

3. P[i]在Ｓ中的连续序列l~r满足对于任意处于l~r范围内的ｊP[j] <= Pi]

4. 对于操作后的序列Ｓ，有多少不同的值则需要多少次操作，这其中应该除开长度为１，且i = j的那些元素构成的序列．

下面设立状态表示ｆ(i, j, k, d)表示已经决定Ｐ中前ｉ个元素在S中的位置，Ｓ中前ｊ个位置已经被占领，剩下ｋ次操作的方案数，当然每个Ｐ[i]值最多算做一次操作，用一维ｄ记录是否已经消耗了操作．

j = n 时，res = 1

否则如果i = n，res = 0.

其他情况：

如果Ｓ[j]不等于Ｐ[i]的值，转移到ｆ(i+1, j, k, 0);否则

对于ｄ = 1 or i == j,转移到f(i, j+1, k, d), 否则f(i, j+1, k-1, 1).

代码:

 typedef long long LL;
 typedef unsigned US;
 typedef pair<int, int> PII;
 typedef map<PII, int> MPS;
 typedef MPS::iterator IT;
 const int MOD = ;
 const int maxn = ;
 int dp[maxn][maxn][maxn][];
 int l[maxn], r[maxn];

 class AlienAndPermutation{
         public:
         int n, K;
         int dfs(int x, int y, int k, int d) {
             int &res = dp[x][y][k][d];
             if (res != -) return res;
             if (y == n) return res = ;
             if (x == n) return res = ;
             res = ;
             res = dfs(x+, y, k, );
             if (l[x] <= y && y <= r[x]) {
                 if (d ==  || x == y)
                 res = (res + dfs(x, y+, k, d)) % MOD;
                 else if (k > ) res = (res + dfs(x, y+, k-, )) % MOD;
             }
             return res;
         }
         int getNumber(vector <int> P, int K) {
            n = (int)P.size();
            this->K = K;
            memset(dp, -, sizeof dp);
            for (int i = ; i < n; i++) {
                l[i] = r[i] = i;
                while (l[i] -  >=  && P[l[i]-] <= P[i]) l[i]--;
                while (r[i]+ < n && P[r[i]+] <= P[i])  r[i]++;
            }
            return dfs(, , K, );
         }
 };

代码：