【POJ - 3276 】 Face The Right Way 【区间加减+单点查询+翻转特性】

Farmer John has arranged his N (1 ≤ N ≤ 5,000) cows in a row and many of them are facing forward, like good cows. Some of them are facing backward, though, and he needs them all to face forward to make his life perfect.

Fortunately, FJ recently bought an automatic cow turning machine. Since he purchased the discount model, it must be irrevocably preset to turn K (1 ≤ K ≤ N) cows at once, and it can only turn cows that are all standing next to each other in line. Each time the machine is used, it reverses the facing direction of a contiguous group of K cows in the line (one cannot use it on fewer than K cows, e.g., at the either end of the line of cows). Each cow remains in the same location as before, but ends up facing the opposite direction. A cow that starts out facing forward will be turned backward by the machine and vice-versa.

Because FJ must pick a single, never-changing value of K, please help him determine the minimum value of K that minimizes the number of operations required by the machine to make all the cows face forward. Also determine M, the minimum number of machine operations required to get all the cows facing forward using that value of K.

Input
Line 1: A single integer: N
Lines 2.. N+1: Line i+1 contains a single character, F or B, indicating whether cow i is facing forward or backward.
Output
Line 1: Two space-separated integers: K and M
Sample Input
7
B
B
F
B
F
B
B
Sample Output
3 3
Hint
For K = 3, the machine must be operated three times: turn cows (1,2,3), (3,4,5), and finally (5,6,7)

分析：
对于翻转问题，重要的要知道两点
第一： 同一个点 翻转两次及以上没有意义。
第二：翻转的顺序是无所谓的。

定义 0是面向后方，1是面向前方。
对于本题： 我们可以枚举k，然后从左到右遍历大小为k的区间，如果每个区间的最左端的是0，那么当前的这个区间就是需要翻转。依次判到最后就行。
我们枚举k的时候已经是o(n)的时间复杂度了，然后我们在枚举大小为k的区间，这时候时间已经为o(n*n)了，但是我们还要进行区间加减和单点查询，这样下来 连BIT都用不了。
但是突然想到 有一个题目，区间查询+单点更新都是o(1)的，当然这个方法有局限性，查询一个dp[i]的时候是需要从dp[1]…递推到dp[i] 。 如果查询很多次，肯定是不行，但是针对这个题目，正正好，要的就是 从前往后递推。

综上所述，我们可以将问题缩短在o(n*n)过。

int a[N]; int num[N]; // 当时题目找不到了，但是差不多就是这么写，如果有bug欢迎指出
void solve(){  //  n个数，q次区间操作，一次查询  
    memset(num,0,sizeof(num));
    int n,q; scanf("%d%d",&n,&q);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);//  原序列

    while(q--){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        num[a]+=c;
        num[b+1]+=-c;  // 和BIT的区间加减基本思想差不多
    }
    for(int i=1;i<=n;i++)  {
        num[i]+=num[i-1];   // num[i] 表示第i个数字比第i-1个数字大多少
        printf("%d ",a[i]+num[i]);
    }
}

代码

#include<cstdio>
#include<cmath>
#include<vector>
#include<algorithm>
#include<cstring>
using namespace std;
#define LL long long
#define ULL unsigned long long

const int N = 5e3+11;
const int M = 1e6+11;
const int inf =0x3f3f3f3f;
const int mod = 1e9+7;
const int inff = 0x3f3f3f3f3f3f3f3f;

/*-------------------------------------*/

int num[N]; int a[N];
// num[i]数组记录着i位置比i-1大多少。
void solve(int n){
    int ans=inf,as;
    for(int k=n;k>=0;k--){
        int t=0;
        memset(num,0,sizeof(num));
        for(int s=1;s<=n-k+1;s++){
           num[s]+=num[s-1];
            if((num[s]+a[s])%2==0){
                t++;
                num[s]+=1;
                num[k+s-1+1]+=-1;
            }
        }
        int flag=1;
        for(int s=n-k+2;s<=n;s++){
            num[s]+=num[s-1];
            if((num[s]+a[s])%2==0) {
                flag=0; break;
            }
        }
        if(flag && ans>t){
            ans=t; as=k;
        }
    }
    printf("%d %d\n",as,ans);
}
int main(){
    int n;scanf("%d",&n);
    for(int i=1;i<=n;i++){
       char s[3];
        scanf("%s",s);
        a[i]=(s[0]=='B'?0:1);
    }
   //  for(int i=1;i<=n;i++) printf("%d " ,a[i]);
    solve(n);
return 0;
}