USACO-Section1.1 Broken Necklace [动态规划]

2017-05-20
题目大意：

给一串项链，项链由3种珠子构成。红珠子 r， 蓝珠子 b 和 白珠子 w。
项链是个圈，比如：

                    1                                1 
            r b b r  2                        b r r b  2
          r         b                       b         b
         r           r                     b           r
        r             r                   w             r
       b               r                 w               w
      b                 b               r                 r
      b                 b               b                 b
      b                 b               r                 b
       r               r                 b               r
        b             r                   r             r
         b           r                     r           r
           r       r                         r       b
             r b r                             r r w
            Figure A                         Figure B
                        r red bead
                        b blue bead
                        w white bead

Figure A 中的项链可以表示为brbrrrbbbrrrrrbrrbbrbbbbrrrrb， 图中的1，2是项链的下标。
现在要把项链从某一位置处拆开，从拆开处向左右两个方向取珠子，左右两个方向上都只能取和端点处颜色相同的珠子，遇到不同颜色的珠子则停止。比如从第8和第9个珠子之间的位置拆开：

                   1   
            r b b r   2     
          r         b     
         r           r  3 
        r             r  4   
       b               r  5     
      b                 b  6  
      b                 b  7     
      b                 b  8  
      r                   <---  拆！
       b               r  9    
        b             r  10      
         r           r  11  
           r       r                  
              b r                              
            Figure C  

逆时针可以取bbb，顺时针可以取rrrrr， 总共取了3+5 = 8个珠子。
我们的目标就是找到这样的位置，使得可以取的珠子的数目最大。
白珠子w 是一种特殊的珠子，它可以当作红珠子或者蓝珠子来使用。（因为白色可以很容易被染成其他颜色）

输入格式：

line1：N， 表示珠子数
line2：N个字符的字符串，表示项链

输出格式：

一个数字，表示最大能取到的珠子数量

样例输入：

29
wwwbbrwrbrbrrbrbrwrwwrbwrwrrb

样例输出：

11

题解：

最简单的想法就是枚举每个位置，然后向两个方向搜索，找到最大能够取到的珠子数量。复杂度$O(n^2)$
但$O(n)$ 的动态规划也不是特别难想。可以用两个数组 pos[] 和 rev[]，分别存储每个节点处正向能取到的最多的连续珠子个数和反向能取到的最多的连续珠子的个数。最后枚举所有的断开点（i与i+1之间），答案就是max(rev[i]+pos[i+1])。
把复杂的问题分成两个相对简单的子问题，然后再根据子问题的解计算原问题的解。

先来分析一下rev数组是如何计算的：
初始化：rev[0] = 1, 从第一个珠子向前取最多能取1个连续的珠子（下标从0开始）
继续讨论之前，有两个需要特别注意的地方:
一、因为有白珠子这种特殊的存在，只根据necklace[i-1]是无法判断necklace[i]能够与前面的珠子相连的。所以我们用字符pre 表示前一种珠子的颜色。pre初始为necklace[0]。

二、当前珠子necklace[i] 与 pre不匹配的时候，rev[i]不一定为1， 有可能necklace[i-k]~necklace[i-1]都是白珠子w, necklace[i]与这几个白珠子是可以相连的。所以我们需要一个数组w[], w[i]表示从第i个珠子开始反向连接的最多的白珠子的个数。当necklace[i] 与 pre不匹配， rev[i] = w[i-1]+1

下面继续讨论rev的计算过程
1. 如果pre == ‘w’ ，并且necklace[i] != ‘w’ ，则标记项链的颜色pre = necklace[i], 并且rev[i] = rev[i] + 1
2. 如果 necklace[i] == ‘w’， 那么肯定能和前面的珠子相连， rev[i] = rev[i] + 1, 同时w[i] = 1, w[i] += w[i-1]。（w[]一开始要全部初始化为0）
3. 如果necklace[i] == pre，匹配成功， rev[i] = rev[i-1] + 1
4. 其他情况，即necklace[i] != pre， 与前面珠子颜色不匹配的情况。这时rev[i] = w[i-1] + 1, 然后改变pre的颜色，pre = necklace[i]。

pos[]的构造过程与rev[]类似。
最后找到 $max(rev[i] + pos[i+1])$ 就是答案。

---

按照官方的题解，pos和rev还可以分解为更小更易求的子问题： 分别求正向和反向的r[]（连续红珠子个数）和b[]（连续蓝珠子个数）, 这样就不需要额外添加变量pre 和数组w[]和这么多特殊情况。
r[0] = b[0] = 0
If c = ‘r’ then r[p+1] = r[p] + 1 and b[p+1] = 0
because the length of the blue beads is 0.
if c = ‘b’ then b[p+1] = b[p] + 1 and r[p+1] = 0
if c = ‘w’ then both length of the red and length of blue beads
can be longer.
so r[p+1] = r[p]+1 and b[p+1] = b[p] + 1.

代码：

/*
ID: zachery1
PROG: beads
LANG: C++
*/
#include <iostream>
#include <fstream>
#include <string>
#define MAXN 1000
//#define cin fin
//#define cout fout
using namespace std;
ifstream fin("beads.in");
ofstream fout("beads.out");
int N;
int rev[MAXN], pos[MAXN]; //Positive order and Reverse order
int w[MAXN];
string necklace;

int main() {
    cin >> N >> necklace;
    necklace += necklace;
    fill(pos, pos+2*N, 1);
    fill(rev, rev+2*N, 1);
    fill(w, w+2*N, 0);

    //Reverse order
    char pre = necklace[0];
    for (int i = 1; i < 2*N; i++) {
        if (pre == 'w' && necklace[i] != 'w') {
            pre = necklace[i];
            rev[i] = rev[i-1] + 1;
        }
        else if (necklace[i] == 'w') {
            rev[i] = rev[i-1] + 1;
            w[i] = 1;
            w[i] = w[i-1] + 1;
        }
        else if (necklace[i] == pre) {
            rev[i] = rev[i-1] + 1;
        }
        else {
            pre = necklace[i];
            rev[i] += w[i-1];
        }
    }

    //Positive order
    fill(w, w+2*N, 0);
    pre = necklace[2*N-1];
    for (int i = 2*N-2; i >= 0; i--) {
        if (pre == 'w' && necklace[i] != 'w') {
            pre = necklace[i];
            pos[i] = pos[i+1] + 1;
        }
        else if (necklace[i] == 'w') {
            pos[i] = pos[i+1] + 1;
            w[i] = 1;
            w[i] += w[i+1];
        }
        else if (necklace[i] == pre) {
            pos[i] = pos[i+1] + 1;
        }
        else {
            pre = necklace[i];
            pos[i] += w[i+1];
        }
    }
    //Calculate answer
    int ans = 0;
    for (int i = 0; i < 2*N-1; i++) 
        if (rev[i] + pos[i+1] > ans) 
            ans = rev[i] + pos[i+1];
    cout << min(ans, N) << endl;
    return 0;
}