Omkar and Bed Wars【Codeforces Global Round 10 D】【DP】

题目链接 CF-1392D

---

  有N个人围坐成一个环，每个人会打左边或者右边的那个人，如果只有某一边的人打他，那么他就会只打这一边（打回去），否则，他打哪一边都是可以的（但是一定要打），现在，为了是给出的长度为N的「L、R」串符合规则，问最小需要修改的次数。

  于是，开始的时候想法是状压DP，我想，某个点i，它收到的影响只会跟前后两个点有关，但是因为我们的正向DP是不能考虑后继的影响，所以如果将状态压进来还是不好处理。

  于是，我们不妨把状态拆出来，那么（作为一个伪环形DP），我们可以存档其中“第一位”和“第N位”的L、R状态，于是可以开两维来记录它，再有，我们需要记录这一位的指向，也就是它打左边的人还是右边的人呢？于是又要开一维，但是这样的遍历情况，我们没法考虑完全它的状态，也就是第i个数，它一定是被i-1和i+1两个位置给联合限制的，所以我们不妨记录第i-1位的指向左右的状态。

  于是，dp的大小就可以确定下来了，，按顺序分别表示访问到第i个节点时候，为了使得前i-1个节点满足条件，并且1号节点的状态为j，N号节点的状态为k，目前这一位（i）选择为q，上一位（i-1）的选择指向是w。在这个时候，满足前i-1个节点是符合规则的最少花费。

  然后，我们就可以根据已有的信息来维护这个dp了。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <unordered_map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 2e5 + 7;
int N;
char s[maxN];
bool dir[maxN];
int dp[maxN][2][2][2][2];

int main()
{
    int T; scanf("%d", &T);
    while(T--)
    {
        scanf("%d", &N);
        scanf("%s", s + 1);
        for(int i=1; i<=N; i++) dir[i] = s[i] == 'R';
        for(int i=0; i<=N; i++) for(int j=0; j<2; j++) for(int k=0; k<2; k++) for(int q=0; q<2; q++) for(int w=0; w<2; w++) dp[i][j][k][q][w] = INF;
        for(int j=0; j<2; j++) for(int k=0; k<2; k++)
        {
            dp[1][j][k][j][k] = (dir[1] ^ j) + (dir[N] ^ k);
        }
        for(int i=2; i<N; i++)
        {
            for(int j=0; j<2; j++)
            {
                for(int k=0; k<2; k++)
                {
                    dp[i][j][k][0][0] = min(dp[i][j][k][0][0], dp[i - 1][j][k][0][1] + dir[i]);
                    
                    dp[i][j][k][0][1] = min(dp[i][j][k][0][1], dp[i - 1][j][k][1][0] + dir[i]);
                    dp[i][j][k][0][1] = min(dp[i][j][k][0][1], dp[i - 1][j][k][1][1] + dir[i]);
                    
                    dp[i][j][k][1][0] = min(dp[i][j][k][1][0], dp[i - 1][j][k][0][0] + !dir[i]);
                    dp[i][j][k][1][0] = min(dp[i][j][k][1][0], dp[i - 1][j][k][0][1] + !dir[i]);
                    
                    dp[i][j][k][1][1] = min(dp[i][j][k][1][1], dp[i - 1][j][k][1][0] + !dir[i]);
                }
            }
        }
        /*j == 0*/
        dp[N][0][0][0][1] = min(dp[N][0][0][0][1], dp[N - 1][0][0][1][0]);
        dp[N][0][0][0][1] = min(dp[N][0][0][0][1], dp[N - 1][0][0][1][1]);
        
        dp[N][0][1][1][0] = min(dp[N][0][1][1][0], dp[N - 1][0][1][0][0]);
        dp[N][0][1][1][0] = min(dp[N][0][1][1][0], dp[N - 1][0][1][0][1]);
        
        dp[N][0][1][1][1] = min(dp[N][0][1][1][1], dp[N - 1][0][1][1][0]);
        /*end*/
        /*j == 1*/
        dp[N][1][0][0][0] = min(dp[N][1][0][0][0], dp[N - 1][1][0][0][1]);
        
        dp[N][1][0][0][1] = min(dp[N][1][0][0][1], dp[N - 1][1][0][1][0]);
        dp[N][1][0][0][1] = min(dp[N][1][0][0][1], dp[N - 1][1][0][1][1]);
        
        dp[N][1][1][1][0] = min(dp[N][1][1][1][0], dp[N - 1][1][1][0][0]);
        dp[N][1][1][1][0] = min(dp[N][1][1][1][0], dp[N - 1][1][1][0][1]);
        /*end*/
        int ans = INF;
        for(int j=0; j<2; j++)  //1st
        {
            for(int k=0; k<2; k++)  //nth
            {
                for(int w=0; w<2; w++)  //(n-1)th
                {
                    if(j == k && k == w) continue;
                    ans = min(ans, dp[N][j][k][k][w]);
                }
            }
        }
        printf("%d\n", ans);
    }
    return 0;
}