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 + 7;
const int maxn = 55*2;
const int maxm = (1<<10) + 10;
int dp[maxn][maxm];

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

    return dfs(2*N, 0);
        }
};

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 = 55;
int dp[maxn][maxn][maxn];
int vis[110];
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 == 0 || y == 0) return res;
    for (int i = 0; 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 == 0 ? 1LL * y * a[pos].val : (0LL + z / ny + a[pos].val) * y)))
        res = (z == -inf ? 1LL * -inf :  (ny == 0 ? 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 = 0;
    for (int i = 0; i < maxn; i++) {
      for (int j = 0; j < maxn; j++) {
        for (int k = 0; k < maxn; k++)
          dp[k][i][j] = -inf;
        mark[0][i][j] = true;
      }
    }
    dp[0][0][0] = 0;

    memset(vis, 0, sizeof vis);

    n = (int)type.size();

    for (int i = 0; i < n;  i++) {
      a[i + 1] = Node(taste[i], type[i]);
    }
    a[0].t = a[0].val = 0;
    sort(a + 1, a + n + 1);
    int ans = 0;
    for (int i = 1; i <= n; i++)
      for (int j = 1; 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 = 100 + 10;
const int maxm = (1 << 10) + 10;
const int MOD =  1000000007;

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 != -1) return res;
        res = 0;
        if (K == 1) {
            res = dfs(n - 1, m + 1, 0);
            if (m > 0)
                res = (res + dfs(n - 1, m - 1, 0)) % MOD;
        } else {
            if (st == 0) {
                if (m == 0) {
                    res = dfs(n - 1, K == 1, K != 1);
                } else {
                    res = dfs(n - 1, m - 1, 0);
                    res = (res + dfs(n - 1, m + (K == 1), K != 1)) % MOD;
                }
            } else {
                if (m == 0) {
                    res = dfs(n - 1, ((st & (1 << (K - 2))) != 0) + (K == 1), (st << 1 | (K != 1)) % M);

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

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 = 1000000007;
const int maxn = 222;
int dp[maxn][maxn][maxn][2];
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 != -1) return res;
            if (y == n) return res = 1;
            if (x == n) return res = 0;
            res = 0;
            res = dfs(x+1, y, k, 0);
            if (l[x] <= y && y <= r[x]) {
                if (d == 1 || x == y)
                res = (res + dfs(x, y+1, k, d)) % MOD;
                else if (k > 0) res = (res + dfs(x, y+1, k-1, 1)) % MOD;
            }
            return res;
        }
        int getNumber(vector <int> P, int K) {
           n = (int)P.size();
           this->K = K;
           memset(dp, -1, sizeof dp);
           for (int i = 0; i < n; i++) {
               l[i] = r[i] = i;
               while (l[i] - 1 >= 0 && P[l[i]-1] <= P[i]) l[i]--;
               while (r[i]+1 < n && P[r[i]+1] <= P[i])  r[i]++;
           }
           return dfs(0, 0, K, 0);
        }
};

代码：