TopCoder 649 div1 & div2

最近一场TC，做得是在是烂，不过最后challenge阶段用一个随机数据cha了一个明显错误的代码，最后免于暴跌rating，还涨了一点。TC题目质量还是很高的，非常锻炼思维，拓展做题的视野，老老实实补题吧。

div2

250pts

题意：判断s去掉一个字符后能否和t一样。

代码：

class DecipherabilityEasy {
    public:
    string check(string s, string t) {
        int n = s.size();
        int m = t.size();
        if(n-1 != m) return "Impossible";
        for(int i = 0; i < n; i++){
                string tmp = "";
            for(int j = 0; j < i; j++)
            tmp += s[j];
            for(int j = i+1; j < n; j++)
                tmp += s[j];
            if(tmp == t) return "Possible";
        }
        return "Impossible";
    }
};

500pts

题意：给定一个长度为n的序列，1 <= n <= 100，可以有两种操作，每次可以将序列从任意位置分成两部分，或者让序列长度减少1，每个操作占1min，每一轮中可以对每个序列进行一次以上操作，问是所有序列消失最短时间，其中split操作的次数不超过k。

分析：dp[n][k]表示对长度为n的序列，最多进行k次split操作时，最短时间。

可以得到以下转移：

dp[n][k] = min(dp[n][k], max(dp[i][j], dp[n-i][k-1-j])+1);

dp[n][k] = min(dp[n][k], n).

代码：

int dp[110][110];
class CartInSupermarketEasy {
public:

    int calc(int N, int K) {
        memset(dp, -1, sizeof dp);
        for(int i = 0; i <= N; i++)
            dp[i][0] = i;
        for(int i = 0; i <= K; i++)
            dp[0][i] = 0;
//            cout << dp[0][0] << endl;
//            cout << (~0) << endl;
        return dfs(N, K);
    }
    int dfs(int x, int y) {
//        if(x == 0) return 0;
//        if(y == 0) return x;
        int &res = dp[x][y];
//        cout << dp[x][y] << endl;
        //        cout << res << endl;
//        cout << x << y << endl;
//        cout << res << endl;
        if(~res) return res;
        res = x;
        res = min(res, dfs(x-1, y) + 1);
        y--;
        for(int i = 1; i < x; i++)
            for(int j = 0; j <= y; j++) {
                res = min(res, max(dfs(i,j), dfs(x-i, y-j))+1);
            }
//        if(res == 0) cout << x << y << endl;
        return res;
    }
};

解题关键：发现split操作后得到的子序列问题是原问题的子问题。

1000pts

题意：数组A[i]，长度n <= 50，求C，令B[i] = A[i]^C，使得B[i]中满足i < j，B[i] < B[j]的数对最多，输出这样的最大值。

分析：考虑两个数A[i]，A[j]异或一个数C的大小关系，考虑两数的二进制位，设从第k位开始，A[i]，A[j]二进制位不同，也就是k+1， k+2及高位都完全相同，设k位(x, 1-x)，那么异或后数B[i]，B[j]大小主要与(x，1-x)及C的第k位(记做y)有如下关系：

x = 0，y = 1，B[i] > B[j];    x = 0，y = 0，B[i] < B[j];

x = 1，y = 1，B[i] < B[j];    x = 1，y = 0，B[i]  > B[j].

此题n不大，枚举第k位，确定第k位为0,1时，能够根据第k位为0或1确定的满足条件i < j，且B[i] < B[j]的对数，取两者中最大值。

代码：

class XorSequenceEasy {
public:
    int getmax(vector <int> A, int N) {
        int ans = 0, B = 0;
        int n = sz(A);
        N = __builtin_popcount(N-1);
//        cout << N << endl;
        for(int i = 0; i < N; i++) {
            int tmp[2];
            tmp[0] = tmp[1] = 0;
            for(int k = 0; k < n; k++)
                for(int l = k+1; l < n; l++) {
                    if(((A[k]^A[l])>=(1<<i)) &&
                            ((A[k]^A[l])<(1<<(i+1))))
                        tmp[(A[k]>>i)&1]++;
                }
            if(tmp[0] < tmp[1]) B |= (1<<i);
        }
//        bug(1)
        for(int i = 0; i < n; i++) A[i] ^= B;
        for(int i = 0; i < n; i++) for(int j = i+1; j < n; j++)
                ans += (A[i] < A[j]);
        return ans;
    }
};

解题关键：发现异或后数的大小关系只和第k位有关。

div1

250pts

题意：字符串s(len <= 50)，从中去掉K个字符之后，能否根据剩下的字符，确定去掉的是哪些字符呢。

分析：去掉K个字符后剩下的字符构成的序列如果不是原s中的唯一序列，那么就不能确定去掉的是哪K个字符，因此，可以枚举s中两个相等的字符s[i]，s[j](i != j)，然后

判断LCS(s[0, i-1], s[0, j-1]) + LCS(s[i+1, len-1], s[j+1, len-1]) + 1 >= len-K么，这样是能判断剩下的序列是否唯一。上面想得略复杂，题解只是判断两个相等字符之间的长度j-i<=K否，因为此时优先移走s[i],s[j]中的一个，然后将i,j之间的字符去掉，剩下的字符已经是相同的了，不论怎么取剩下的字符，最终一定不能确定被移走的是哪些字符。

代码：

const int maxn = 55;
char sa[maxn], sb[maxn];
string str;
int dp[maxn][maxn];

class Decipherability {
public:
    int len;
    int LCS(int n, int m, bool rev) {
        if(n == 0 || m == 0) return 0;
        if(rev) {
            for(int i = n-1; i >= 0; i--)
                sa[n-1-i] = str[i];
            for(int i = m-1; i >= 0; i--)
                sb[m-1-i] = str[i];
        } else {
            for(int i = 0; i < n; i++)
                sa[i] = str[len-n+i];
            for(int i = 0; i < m; i++)
                sb[i] = str[len-m+i];
        }
        memset(dp, 0, sizeof dp);
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= m; j++)
                if(sa[i-1] == sb[j-1]) {
                    dp[i][j] = dp[i-1][j-1] + 1;
                } else {
                    dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
                }
        return dp[n][m];
    }
    string check(string s, int K) {
        str = s;
        len = sz(s);
        if(len == K) return "Certain";
        int ok = 1;
        for(int i = 0; i < len; i++)
            for(int j = i+1; j < len; j++)if(s[i] == s[j]) {
                    if(LCS(i, j, true)+LCS(len-i-1, len-j-1, false) >= len-K-1) {
                        ok = 0;
                        break;
                    }
                }
        return ok ? "Certain" : "Uncertain";
    }
};

解题关键：剩下的字符构成的序列在原字符串中不唯一。

550pts

题意：div2 500pts升级版，之前已经知道B[i]，B[j]的大小只和第k位(x,1-x)及C的第k位y有关。

因此当y为0，需要知道A[j]第k位为1时，i < j 且A[i]的第k位为0 的个数；当y为1，A[j]第k位为0时，i < j，且A[i] 第k位为1的个数，注意A[i]，A[j]的k+1位及更高位都应该相同，这样便能够分别统计C的第k位为0,1确定的(i, j)的个数(B[i] < B[j], i < j) 。

对A[i]排序后得到A'[l, r]，从最高位开始，每次统计位于A'[l,r]范围的A[j]，当A[j]的第k位为1或0时,位于A[j]之前且k位 为0或1的A[i](i < j)的个数，统计后根据第k位为0 或 1，分成A'[l, mid], A'[mid+1, r]两部分继续统计第k-1位能够确定的数对(i, j)的个数。划分成A'[l, mid], A'[mid+1, r]的目的是为了保证高位都相同，进而对下一位进行统计。具体可以用树状数组实现，为了免去每次都要对数组置零的耗时，可以对数组的每个元素设一个标记。

代码：

const int maxn = 131072 + 10;

int order[maxn], A[maxn];
LL ma[33][2];
LL res[maxn][2];
int cnt;

bool cmp(const int &x, const int &y) {
    return A[x] < A[y];
}

class XorSequence {
public:

    void add(int x, int v) {
        while(x < maxn) {
            if(res[x][1] != cnt) {
                res[x][0] = 0;
                res[x][1] = cnt;
            }
            res[x][0] += v;
            x += lowbit(x);
        }
    }
    LL query(int x) {
        LL ans = 0;
        while(x > 0) {
            if(res[x][1] != cnt){
                res[x][0] = 0;
                res[x][1] = cnt;
            }
            ans += res[x][0];
            x -= lowbit(x);
        }
        return ans;
    }
    void dfs(int l, int r, int dep) {
        if(l > r || dep < 0) return;
        int mid = l-1;
        while(mid+1 <= r) {
            if(!(A[order[mid+1]]&(1<<dep)))
                mid++;
            else break;
        }

        if(mid >= l && mid < r) {
            cnt++;
            //memset(res[dep], 0, sizeof(res[dep]));
            for(int i = l; i <= mid; i++)
                add(order[i], 1);
            for(int i = mid+1; i <= r; i++) {
                ma[dep][0] += query(order[i]);
            }
            // memset(res[dep], 0, sizeof(res[dep]));
            cnt++;
            for(int i = mid+1; i <= r; i++)
                add(order[i], 1);
            for(int i = l; i <= mid; i++)
                ma[dep][1] += query(order[i]);
        }
        dfs(l, mid, dep-1);
        dfs(mid+1, r, dep-1);
    }
    long long getmax(int N, int sz, int A0, int A1, int P, int Q, int R) {
        A[1] = A0;
        A[2] = A1;
        for (int i = 3; i <= sz; i++) {
            A[i] = (1LL*A[i - 2] * P%N + 1LL*A[i - 1] * Q%N + R) % N;
        }
        int n = __builtin_popcount(N-1);
//        for(int i = 1; i <= sz; i++)
//            printf("%d ", A[i]);
//        cout << endl;

        for(int i = 1; i <= sz; i++)
            order[i] = i;
        sort(order + 1, order + sz + 1, cmp);
        cnt = 0;
        memset(ma, 0, sizeof ma);
        memset(res, 0, sizeof res);

        dfs(1, sz, n-1);
        LL ans = 0;
        for(int i = 0; i < n; i++)
            ans += max(ma[i][0], ma[i][1]);
        TL
        return ans;
    }
};

解题关键：排序后根据第k位对数组进行分组，统计。

850pts

题意：div2 500pt升级版，范围更大，且开始给定的n ( n <= 50)个序列，长度len及能够进行的split操作总次数<=1e9。

分析：官方题解是采用二分时间，然后在确定时间下单独考虑消除每个序列，二分需要的最少split次数，最后判断总的split次数是否<=splits。

难点在于怎么二分确定需要的最少split次数，题解里面给出了一系列证明，总结起来就是：先进行split操作，然后进行remove操作，这样结果肯定是更优的；

split的次数越多，结果更优。因此首先进行split操作，一个序列能够split成两个时，则split，如果满足split次数，能够继续将两个序列split成四个时，则split，继续split直到不能split所有序列，那么利用剩余的split次数对部分序列split，对没有split的其他部分序列进行remove操作，此时时间记做T1。剩余部分需要的时间T2和剩下的序列总长度，n'有关，即T2 = ，判断T1+T2 <= timeLimit。

代码：

class CartInSupermarket {
public:
    int calcmin(vector <int> a, int b) {
        int low = 1, high = (int)1e9;
        while(low < high) {
            int mid = (low+high)/2;
            if(possible(a, mid, b)) high = mid;
            else low = mid+1;
        }
        return low;
    }
private:
    bool possible(vector<int> a, int timeLimit, int b) {
        LL sum = 0;
        for(int x: a) sum += numSplits(x, timeLimit);
        return sum <= b;
    }
    int numSplits(int x, int timeLimit) {
        int low = 0, high = x;
        while(low < high) {
            int mid = (low+high)/2;
            if(possible(x, mid, timeLimit)) high = mid;
            else low = mid + 1;
        }
        if(low == x) return (int)1e9 + 100;
        return low;
    }
    bool possible(LL x, LL numSplits, int timeLimit) {
        LL numParts = 1;
        int tl = 0;
        while(numParts <= numSplits){
            numSplits -= numParts;
            numParts *= 2;
            tl++;
        }
        x = max(0LL, x-(numParts-numSplits));
        return (tl + 1) + (x + numParts + numSplits - 1) / (numParts + numSplits) <= timeLimit;
    }
};

解题关键：二分时间，并二分split次数，确定的splits次数下，最优化进行操作的过程。