[Luogu5205] [USACO19JAN-Platinum] Redistricting [单调队列&DP / 线段树]

探讨了一种算法，旨在将包含G和H字符的字符串分割成若干区，以确保每个区中G的数量不少于H的数量，同时使满足条件的区数量达到最少。采用前缀和与单调队列优化策略，通过分类讨论实现高效转移。

[ $\frak{Link}$ ]

把一列长为 $n$ 的字符串分成若干个区，使 $\ge count('H')$ 的区的数量最少。

化为正负一，前缀和画一下图，考虑分类讨论转移：
如果在区间内能转移到的点的高度都不高于当前点，就取区间内最低的那个点；
否则转移到高度恰好高 1 的区间内最靠右的点。

显然可以单调队列优化（移动窗口），根据用不用可能T或者不T（
用单调队列的话就没办法旋转跳跃闭着眼转移了，得滴批。

能过(USACO限定)
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<ctime>
#include<cctype>
#include<iostream>
#include<algorithm>
using namespace std;
int n, k;
const int MAXN = 300005;
const int MAXST = 20;
const int INF = 0x3f3f3f3f;
bool lst[MAXN];
int sum[MAXN];
string str;
pair<int,int> Seg[4*MAXN];
void SegBuild(int Pos, int L, int R)
{
    if (L==R)
    {
        Seg[Pos] = make_pair(sum[L],L);
        return;
    }
    int Mid = L + R >> 1;
    SegBuild(Pos<<1,L,Mid);
    SegBuild(Pos<<1|1,Mid+1,R);
    Seg[Pos] = (Seg[Pos<<1].first<Seg[Pos<<1|1].first)?Seg[Pos<<1]:Seg[Pos<<1|1];
}
pair<int,int> Query(int Pos, int L, int R, int qL, int qR)
{
    if (R < qL || L > qR) return make_pair(INF,-1);
    if (L >= qL && R <= qR)
    {
        return Seg[Pos];
    }
    int Mid = L + R >> 1;
    pair<int,int> A1 = Query(Pos<<1,L,Mid,qL,qR);
    pair<int,int> A2 = Query(Pos<<1|1,Mid+1,R,qL,qR);
    return (A1.first<A2.first)?A1:A2;
}
int main()
{
//	freopen("redistricting.in", "r", stdin);
//	freopen("redistricting.out", "w", stdout);
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
    cin >> n >> k >> str;
    for (int i = 0; i < n; ++i)
    {
        lst[i + 1] = (str[i] == 'H');
        sum[i + 1] = sum[i] + (lst[i + 1] ? 1 : -1);
    }
    SegBuild(1, 1, n);
    int pos = 0;
    int ans = 0;
    while (pos < n)
    {
        int trans = -1;
        for (int i = min(n,pos+k); i >= pos+1; --i)
        {
            if (sum[i] == sum[pos] + 1) 
            {
                trans = i;
                break;
            }
        }
        if (trans != -1)
        {
            pos = trans;
        }
        else
        {
            pos = Query(1, 1, n, pos+1, min(n,pos+k)).second;
            ++ans;
        }
    }
    printf("%d", ans);
    return 0;
}

单调队列（初始化比较多，小心
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<ctime>
#include<cctype>
#include<iostream>
#include<deque>
#include<algorithm>
using namespace std;
int n, k;
const int MAXN = 300005;
const int MAXST = 20;
const int INF = 0x3f3f3f3f;
bool lst[MAXN];
int sum[MAXN];
int rit[MAXN];
int dp[MAXN];
string str;
int lack = INF;
deque<int> Q;
#define UPDATE_MIN(a,b) a=min(a,b)
int main()
{
	freopen("redistricting.in", "r", stdin);
	freopen("redistricting.out", "w", stdout);

	//INPUT
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
    cin >> n >> k >> str;
    for (int i = 0; i < n; ++i)
    {
        lst[i + 1] = (str[i] == 'H');
        sum[i + 1] = sum[i] + (lst[i + 1] ? 1 : -1);
        lack = min(lack, sum[i+1]);
    }
    
    //INIT_ETC
    lack = -lack+1;
    int ans = 0;
    
    //INIT_DP
    memset(dp, 0x3f, sizeof(dp));
    for (int i = 1; i <= k; ++i) dp[i] = 1;
    
    //INIT_DEQUE
    for (int i = 1; i <= k; ++i)
    {
    	while (!Q.empty() && sum[Q.back()] >= sum[i]) Q.pop_back();
    	Q.push_back(i);
    	rit[lack+sum[i]] = i;
    }
    if (rit[lack+1]) dp[rit[lack+1]] = 0;
    
    for (int gg, popo, i = 1; i < n; ++i)
    {
    	//Delete
    	while(!Q.empty() && Q.front() <= i) Q.pop_front();
    	
    	gg = i+k;
    	//Insert
    	if (gg <= n)
    	{
    		while (!Q.empty() && sum[Q.back()] >= sum[gg]) Q.pop_back();
    		Q.push_back(gg);
    		rit[lack+sum[gg]] = gg;
    	}
    	
    	popo = lack+sum[i]+1;
    	//Etc.
    	if (rit[popo])
		{
			UPDATE_MIN(dp[rit[popo]], dp[i]);
		}
		UPDATE_MIN(dp[min(n,gg)], dp[i] + 1);
		UPDATE_MIN(dp[Q.front()], dp[i] + 1);
    }
    printf("%d", dp[n]);
    return 0;
}