小红的01子序列构造（easy）

我们将使用拉马努金瞪眼法解决这一题

注意到：题目说了是双指针

证明：
为什么用双指针能行，假设题目的答案在这一段，如果当前的，就有两种情况

一是当前出现次数，则 r 继续向前

二是当前出现次数，则 l 向前。由于 r 是小于 R 的，如果 r 这一步走了之后，，那么当前出现次数 now 一定大于等于 k，l 一定小于等于 L，如果 l 向前走了，now 就会变小

当，，也就是说，，答案就出来了

注意到，代码要写成这样：

void solve()
{
    ll n = q_;
    ll k = q_;
    string num;
    cin >> num;

    ll now = 0, cnt_1 = 0, cnt_0 = 0, l = -1, r = -1;
    while (r+1 < n)
    {
        r++;
        (num[r] - '0') ? (cnt_1++, now += cnt_0) : (cnt_0++);
        while (now > k)
        {
            l++;
            (num[l] - '0') ? (cnt_1--) : (cnt_0--, now -= cnt_1);
        }
        if (now == k)
        {
            cout << l+2 << ' ' << r+1 << endl;
            return;
        }
    }
    cout << -1 << endl;
    return;
}

int main()
{
    int t = 1;
    while (t--)
    {
        solve();
    }

    return 0;
}


/*
⡀⠎⠀⠀⠀⠀⠀⠀⠀⣸⣿⣿⣿⣿⣄⠃⠈⣶⡛⠿⠭⣉⠛⠿⡿⠛⠉⣀⣠⣤⣭⡏⠴⢀⣴⣿⣿⣿⣿⣿⣿⠀⠀⠀⠀⠀⠀⠀⠙⣿⣿
⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣷⣱⣬⠛⠉⠀⠀⢠⠀⠀⠀⢀⣀⠀⠉⠿⣿⣾⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀⠀⠀⠀⠀⠀⠀⠈⡿
⠀⠀⠀⠀⠀⠀⠀⢀⢿⣿⣿⣿⣿⣿⣿⠋⠀⠀⠀⠀⠀⡏⠀⠀⠀⠀⠈⠳⠀⠀⠀⠻⣿⣿⣿⣿⣿⣿⠋⠀⣇⠀⠀⠀⠀⠀⠀⠀⠀⠈
⠀⠀⠀⠀⠀⠀⠀⣸⠀⣿⣿⣿⣿⠟⠀⠀⠀⠂⠀⠀⢠⠀⠀⠀⠀⠀⠀⠀⠈⡀⠀⠀⠀⠻⣿⣿⣿⣿⣷⡀⠘
⠀⠀⠀⠀⠀⠀⠀⣧⣿⣿⣿⣿⠋⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠈⠀⠀⠀⠀⠙⣿⣿⣿⣿⣿⣄⣧
⠀⠀⠀⠀⠀⠀⣸⣿⣿⣿⣿⠁⠀⠀⠀⠀⠀⠀⠀⠀⣾⠀⠀⠀⠀⠀⠀⠀⠀⠀⢧⠀⠀⠀⠀⠈⢿⣿⣿⣿⣿⣿⣆
⠀⠀⠀⠀⠀⢀⣿⣿⣿⣿⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⢹⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠀⠀⠀⠀⠀⢂⠻⣿⣿⣿⣿⣿⣄
⠀⠀⠀⠀⠀⣿⣿⣿⣿⣹⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣇⠀⠀⠀⠀⠀⡄⠈⢿⣿⣿⣿⣿⣆
⠀⠀⠀⠀⣿⣿⣿⣿⠁⡇⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠀⠀⠀⠀⠐⠸⠀⠀⠻⣿⣿⣿⣆⢦
⠀⠀⢠⣿⣿⣿⣿⠃⠀⠀⠀⠀⠀⠀⠀⣼⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡏⣧⠀⠀⠀⠀⠐⣇⠀⠀⠙⣿⣿⣿⡄⠙⣄
⠀⣴⣿⣿⣿⣿⠏⠀⢸⠀⠀⠀⠀⠀⠀⡿⢿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣃⣈⣦⠀⠀⠀⠀⢹⠀⠀⠀⠸⣿⣿⣿⠀⠀⠳⣀
⠋⣸⣿⣿⣿⡟⠀⠀⠀⡆⠀⠀⠀⠀⠀⡏⠙⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠀⢠⠀⠀⠀⢧⠀⠀⠀⠀⡇⠀⠀⠀⠘⣿⣿⣷⠀⠀⠘
⠀⣿⣿⣿⢩⠀⠀⠀⠀⣿⠀⠀⠀⠀⠀⣀⠀⢱⠀⡀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠀⠂⢀⣴⣶⣿⣿⡀⠀⠀⢻⠀⠀⠀⠀⠹⣿⣿⡄
⢸⣿⣿⠃⠈⠀⠀⢸⠀⣿⣆⠀⠀⠀⠀⣿⣿⣿⠷⠘⡀⠀⠀⠀⠀⠀⠀⢠⢹⡀⠈⡿⠻⣿⣛⢿⣿⣷⡀⠈⠀⠀⠀⠀⠀⢻⣿⣿
⣿⣿⣿⠀⠀⠀⠀⢸⠀⡇⣼⣄⠀⠀⠀⢻⣿⡄⠑⠑⣿⡀⠀⠀⠀⢀⠀⠂⠇⠀⠀⠖⠛⢿⣿⣿⣌⢿⣿⣿⡆⠀⠀⠀⠀⠀⣿⣿⡀
⣿⣿⡇⠀⠀⠀⠀⢸⠀⣾⣿⣿⡷⠿⣷⣤⣿⣿⡄⠀⠀⠀⠑⠤⡀⠀⠃⠀⠀⠀⠀⣿⣶⣿⣿⣿⣿⣆⠙⣿⣧⠀⠀⠀⠀⠀⣿⣿⡇
⣿⣿⠁⠀⠀⠀⠀⠘⣾⣿⣿⠁⣴⣿⣿⣿⣿⣿⣇⠀⠀⠀⠀⠀⠀⠈⠀⠀⠀⠀⠀⠸⡏⠙⣿⠉⠻⣿⠀⠀⣿⠀⠀⠀⣄⠀⣿⢸⣷
⣿⣿⡇⠀⠀⠀⠀⠀⣿⣿⠁⠀⣿⣿⠋⣿⠏⠙⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢹⠀⢀⢻⠀⠀⢀⡟⢀⣿⣸⢃⠟
⣿⣿⣿⠀⡄⠀⠀⠀⠘⠻⡄⠀⢹⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡘⠀⢀⣿⠃⣿⣿⡗⠁
⣧⣿⣿⣧⢹⡀⠀⠀⠀⠱⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠀⣴⣿⣿⣾⣿⣿⣿
⢿⠘⣿⣿⣿⣿⣤⠀⠢⡀⠱⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣵⣿⣿⣿⣿⣿⣿⣿⣿⣷
⠀⠉⣿⣿⣿⡿⣿⠻⣷⣬⣓⣬⣄⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠉⠈⠈⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⠃⠼⢉⣿⣿⣿⣿⣿⣿⣿
⠀⠀⣿⣿⣿⣷⠀⠀⠀⠘⣿⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣾⣿⡏⠀⠀⢸⠀⢻⢿⣿⣿⡏⣿
⠀⢸⣿⣿⣿⣿⠀⠀⠀⠀⢻⣿⣿⣤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣴⣾⣿⣿⣿⣿⠀⠀⠀⢸⠀⠀⢸⣿⣿⠘⡀
⢦⡿⣿⣿⣿⢿⠀⠀⠀⠀⢸⣿⣿⣿⣿⣿⣿⣿⣶⣶⣦⡄⠀⠀⠀⠀⠀⠀⠀⠀⣰⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀⠀⠘⡄⠀⠈⣿⣿⡄⠱
⣴⠛⣾⣿⣿⢸⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠿⡄⠀⠀⠀⠀⠀⠀⠀⣯⠛⣿⣿⣿⣿⣿⣿⣿⠀⠀⠀⠀⣇⠀⠀⣿⣿⣿
⠿⠀⣿⣿⣿⠀⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⠟⠰⡾⠃⠀⠀⠀⠀⠀⠀⠀⠙⡟⠀⢻⣿⣿⣿⣿⣿⡆⠀⠀⠀⠸⠀⠀⠸⣿⣿⣷
⠆⢳⣿⣿⡇⠀⠀⠀⠀⠀⠀⣿⣿⣿⠛⠿⠿⢿⡟⠀⠀⠉⠦⣀⡤⢶⠀⠖⠲⠶⠊⠀⠀⠀⢻⡛⠛⠛⣿⣿⠀⠀⠀⠀⠃⠀⠀⢿⣿⣿
*/

ll dp[N],cnt1[N],cnt0[N];
ll ck(int l,int r){
    return dp[l]-dp[r+1]-((cnt0[l]-cnt0[r+1])*cnt1[r+1]);
}
void solve(){
    ll n,k;
    cin>>n>>k;
    string s;cin>>s;
    s='$'+s;
    for(int i=n;i>=1;i--){
        if(s[i]=='1')dp[i]=dp[i+1];
        else dp[i]=dp[i+1]+cnt1[i+1];
        cnt1[i]=cnt1[i+1]+(s[i]=='1');
        cnt0[i]=cnt0[i+1]+(s[i]=='0');
    }
    for(int i=1;i<=n;i++){
        int L=i+1,R=n,ans=-1;
        while(L<=R){
            int mid=(L+R)>>1;
            if(ck(i,mid)<=k){
                ans=mid;
                L=mid+1;
            }else{
                R=mid-1;
            }
        }
        if(ans!=-1){
            if(ck(i,ans)==k){
                cout<<i<<" "<<ans<<'\n';
                return ;
            }
        }
    }cout<<-1<<'\n';
}   

注意到字串变长时，其中的 01 子序列数量单调不减，故可以用二分。

（注释由 AI 生成，但是 AI 太笨了不会讲原理，基本只是在解释每一步做了什么）

# 导入operator模块的le方法（注：当前代码中未实际使用该方法，属于冗余导入）
from operator import le
# 读取输入的n和k：n为字符串长度，k为目标匹配值
# strip()去除首尾空白，split()按空格分割，map(int, ...)转换为整数类型
n, k = map(int, input().strip().split())
# 读取输入的二进制字符串s（仅包含'0'和'1'）
s = input().strip()
# 前缀数组：pre_0[i] 表示字符串s的前i个字符（s[0..i-1]）中'0'的个数
# 长度为n+1，方便处理边界情况（前缀和常用初始化方式）
pre_0 = [0] * (n + 1) 
# 后缀数组：suf_1[j] 表示字符串s从j位置开始到末尾（s[j..n-1]）中'1'的个数
suf_1 = [0] * n 
# 后缀数组：suf_01[j] 表示字符串s从j位置开始到末尾，每个'0'对应的后续'1'的个数之和
# 即对于s[j..n-1]中的每个'0'，累加其右侧（包括自身之后）的'1'数量，最终求和
suf_01 = [0] * n 
# 初始化suf_1的最后一个元素（最右侧字符）：如果是'1'，则后缀1的个数为1
if s[-1] == '1':
    suf_1[-1] = 1
# 循环遍历，同时构建前缀数组pre_0和后缀数组suf_1、suf_01
for i in range(n):
    # 构建pre_0：继承前一个位置的前缀0个数（pre_0[i-1]）
    # 注：i=0时，pre_0[i-1] = pre_0[-1]，即pre_0数组的最后一个元素（初始为0）
    pre_0[i] = pre_0[i - 1]
    # 如果当前字符是'0'，前缀0的个数加1
    if s[i] == '0':
        pre_0[i] += 1

    # 当i>0时，反向遍历构建后缀数组（j = n-1-i 从倒数第二个字符向前遍历）
    if i > 0:
        # 计算反向遍历的索引j（从后往前第i+1个位置）
        j = n - 1 - i
        # 构建suf_1：继承j+1位置的后缀1个数（右侧的后缀1总数）
        suf_1[j] = suf_1[j + 1]
        # 如果当前字符是'1'，后缀1的个数加1
        if s[j] == '1':
            suf_1[j] += 1

        # 构建suf_01：继承j+1位置的suf_01值（右侧的0对应1的累计和）
        suf_01[j] = suf_01[j + 1]
        # 如果当前字符是'0'，则累加当前位置右侧的1的个数（suf_1[j]）到suf_01[j]
        if s[j] == '0':
            suf_01[j] += suf_1[j]
# 自定义二分查找函数：在区间[i, n-1]中查找符合target条件的最大索引j
# 参数i：查找的左边界起始位置；target：目标匹配值
def bisect(i, target):
    # 二分查找的左边界（起始为i）和右边界（末尾为n-1）
    left = i 
    right = n - 1
    # 二分查找循环：当左边界不超过右边界时继续
    while left <= right:
        # 计算中间索引mid（等价于(left + right) // 2，位运算更高效）
        mid = left + right >> 1
        # 计算决策值dec：用于判断是否满足目标条件
        # 组成：suf_01[mid]（mid右侧0对应1的累计和） + 区间[i, mid-1]内0的个数 * suf_1[mid]（mid右侧1的个数）
        dec = suf_01[mid] + (pre_0[mid - 1] - pre_0[i - 1]) * suf_1[mid]
        # 如果dec大于等于目标值，说明需要向右查找更大的索引
        if dec >= target:
            left = mid + 1
        # 否则向左查找
        else:
            right = mid - 1

    # 循环结束后，计算右边界right对应的dec值（验证是否符合目标）
    dec = suf_01[right] + (pre_0[right - 1] - pre_0[i - 1]) * suf_1[right]
    # 如果dec等于target，返回right（找到符合条件的索引）；否则返回特殊值-114514（标记未找到）
    return right if dec == target else -114514 
# 核心求解函数：查找满足条件的字符串区间[i+1, j]（题目要求输出1-based索引）
def solve():
    # 遍历每个可能的起始位置i（0-based，对应字符串s的第i个字符）
    for i in range(n):
        # 情况1：如果从i位置到末尾的suf_01值恰好等于k，直接返回区间[i+1, n]（1-based）
        if suf_01[i] == k:
            return f'{i + 1} {n}'
        # 情况2：如果从i位置到末尾的suf_01值小于k，说明不存在符合条件的区间，返回'-1'
        if suf_01[i] < k:
            return '-1'
        # 情况3：计算目标值target = 当前suf_01[i] - k，用于二分查找
        target = suf_01[i] - k 
        # 调用二分查找函数，查找符合target条件的j
        j = bisect(i, target)
        # 如果j返回特殊值（未找到），继续遍历下一个i
        if j < 0:
            continue 
        # 找到符合条件的j，返回区间[i+1, j]（1-based索引）
        return f'{i + 1} {j}'
# 调用求解函数并打印结果
print(solve())

# ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣤⠶⠟⠛⠛⠛⠛⠷⡶⠶⠿⠛⠷⠶⣦⣤⡀
# ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⠶⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠙⠶⣄
# ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡴⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢶⡀
# ⠀⠀⠀⠀⠀⠀⠀⠀⠀⣴⠫⠒⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢄⠀⠀⠀⠀⠉⢷⡀
# ⠀⠀⠀⠀⠀⠀⣠⡾⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠒⡀⠀⠀⠀⠙⣦
# ⠀⠀⠀⠀⣠⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢆⠀⠀⠀⠘⣧
# ⠀⠀⠀⣴⠁⠀⢀⠤⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢣⠀⠀⠈⢿⡀
# ⠀⠀⡾⠀⣠⢾⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡆⠀⠀⠀⠹⣆
# ⠀⢸⢁⠞⠀⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣠⣿⠀⠀⠀⠀⠀⠀⢰⣿⠑⠢⣄⠀⠀⠀⠀⡀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠘⣆
# ⠀⠘⠃⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠠⠋⢀⢏⢿⠀⠀⠀⠀⠀⢀⣿⣌⣆⠀⠀⣏⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠈⠀⠀⢄⠀⠀⢹⡀
# ⠀⠀⠀⠀⢀⡇⠀⠀⠀⠀⠀⠀⢠⠀⠀⡟⠟⢞⣇⠀⠀⠀⠀⢿⠟⠀⠙⣆⠀⢹⢦⡀⠀⠘⠀⠀⠀⠀⠀⠀⣄⠀⠀⠀⢳⡀⠀⣇
# ⠀⠀⠀⣤⠋⠀⠀⠀⠀⠀⠀⢀⡿⡄⢸⠙⠀⠀⠻⣆⢠⣄⠀⠀⣧⠀⠀⠀⠛⢦⣷⠙⢶⣄⠀⠀⠀⠀⠀⠀⠹⡀⠀⢠⣼⠻⡀⡟
# ⢀⣴⠟⠀⠀⠀⣀⠞⠀⠀⠀⣼⢋⠈⠻⠀⢀⣪⡶⠀⠛⠃⠉⠛⠻⣬⣑⣀⣀⣀⣤⣶⣷⣸⠀⠀⠀⠀⠠⠀⠀⠙⣄⠀⣿⠀⠛
# ⠀⠉⠛⠛⡿⠁⠀⠀⣄⠀⠀⣿⣿⣿⣿⣿⡿⠋⠀⠀⠀⠀⠀⠀⠀⠈⠻⣿⣿⣿⣿⡿⠿⡿⠀⠀⠀⠀⠀⡾⠓⠶⠶⠋⠘⣦
# ⠀⠀⢀⠟⠀⠀⠀⣼⣿⣦⡀⠹⡀⠀⠙⠁⠀⠀⠒⠶⠒⠲⠤⠴⠀⠀⠀⠀⠁⠀⠀⠀⣾⠀⠀⠀⠀⠀⡾⠉⢷⣳⢄⠀⠀⠈⠳⣄
# ⠀⠀⡿⠀⠀⠀⣠⣿⣿⢿⣿⠉⠉⠎⢀⠀⡎⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⠀⠃⢸⠀⣿⡤⣶⠁⠀⢠⣿⣿⠛⢀⣿⡇⡿⠶⣤⣤⣤⠟
# ⠀⠀⡇⠀⡴⢋⣼⠗⣉⢯⣿⣷⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡾⠀⣀⣾⠉⠉⠀⣠⣿⣿⣧⣿
# ⠀⠀⠹⠟⠀⣧⡴⣻⠃⣾⣿⣿⣋⠛⢶⣤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣛⣿⣿⣍⣴⣭⣿⡻⣿⣿⣿⣿⣞⣦
# ⠀⠀⠀⠀⠀⣾⣿⠃⢰⣿⠟⠐⣿⢏⣿⣿⣝⣿⣿⣿⠿⠶⠶⠶⠶⠶⠶⣿⠟⣩⠀⠀⣼⣿⣿⣿⣿⣿⣿⣿⣿⡿⣿⣿⣷⣿⣦⣤
# ⠀⠀⠀⠀⠀⠠⣧⡀⣿⠁⢀⠋⢠⠋⠀⠙⠀⠉⠁⠀⠀⠀⠀⠀⠀⣴⣻⣿⣿⠦⣠⠛⠋⠁⣿⣿⠋⠻⣿⣿⣿⠉⠛⠿⠿⠛⠋
# ⠀⠀⠀⠀⠀⠀⠀⠀⣿⣾⢻⢠⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⢸⣿⡿⣵⠛⠀⠀⠀⠀⠁⠀⠀⠀⣿⠟
# ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠻⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣏⡟⡟
#

#include <bits/stdc++.h>
using namespace std;
using ll=long long;

int main() {
    ll n,k;cin >> n >> k;
    string s;cin >> s;
    ll now;
    ll cnt0=0,cnt1=0;
    ll l=0,r=0;
    if(s[0]=='0') cnt0++;
    else if(s[0]=='1') cnt1++;
    while(now!=k)
    {
        if(now>k)
        {
            l++;
            if(s[l-1]=='0')
            {
                cnt0--;
                now-=cnt1;
            }
            else if(s[l-1]=='1')
            {
                cnt1--;
            }
        }
        else if(now<k)
        {
            r++;
            if(s[r]=='0')
            {
                cnt0++;
            }
            else if(s[r]=='1')
            {
                cnt1++;
                now+=cnt0;
            }
        }
        if(r==n||l==n)
        {
            cout << -1;
            return 0;
        }
    }
    cout << l+1 <<' '<< r+1;
}
/*
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣤⣤⡀⣀⣠⣤⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣀⡀⢀⣴⣾⣷⣶⣾⣿⣿⣿⣿⣿⣿⣿⣿⣷⣾⣿⣷⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣾⣿⣿⣿⣿⣿⣿⣿⠿⠛⠛⠉⠉⠉⠉⠉⠉⠛⠻⠿⣿⣿⣿⣿⣿⣶⣤⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⢠⣾⣿⣿⣿⡿⠿⠛⠉⠉⠉⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠙⠿⣿⣿⣿⣷⣄⡀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⣀⣿⣿⣿⠟⠁⠀⠀⠀⠀⠀⠀⠀⣰⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠿⣿⣿⣿⡄⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⣠⣾⣿⣿⠟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣶⣄⠀⠀⠀⠀⠀⢀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⣻⣿⣿⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⢹⣿⡿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣿⠁⠈⢢⡀⠀⠀⠀⢸⡇⢀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠻⣿⡟⠒⢦⡀⠀⠀⠀
⠀⠀⣠⣤⣤⣼⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⡇⠀⠀⠀⠉⢢⣄⠀⠀⢿⠊⠳⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⣷⡄⠀⢷⠀⠀⠀
⠀⢰⠇⠀⣰⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⡌⣹⠗⠦⣬⣇⠀⠉⢢⡀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⡀⢸⡄⠀⠀
⠀⡟⠀⣼⣯⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣆⢹⡀⠀⠀⠀⠉⠁⠀⠀⢀⣀⡁⠀⠀⠉⠳⢴⡆⠀⠀⠀⠀⠀⠀⢹⣧⠈⡇⠀⠀
⠀⡇⠀⠀⢻⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣾⠻⠉⠛⠂⠀⠀⠀⠀⠀⠀⠻⠿⣿⣿⣿⣶⣦⡀⠛⣇⠀⠀⠀⠀⠀⣈⣿⠀⡇⠀⠀
⢸⡇⠀⠀⢠⣿⣷⣦⣀⡸⣷⣦⣶⡂⠉⠉⠉⢁⣤⣶⡶⠀⠀⠀⣀⣀⡴⠀⠀⠀⠀⠀⠀⠈⠉⠉⠁⠀⡟⢀⣴⣟⣰⣾⣿⣏⣠⠇⠀⠀
⠈⡇⠀⠀⢸⣿⠁⠉⣿⠛⠛⠃⡇⠀⠀⢠⣶⣿⡿⠛⠁⠀⠀⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠼⢿⠟⠿⢿⡏⠀⠘⣿⡀⠀⠀⠀
⠀⢷⣀⣀⣿⠇⠀⠀⢿⡇⠀⢀⢱⡀⠀⠛⠛⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠀⠀⢸⠇⠀⠀⢹⣿⣄⠀⠀
⠀⠀⣉⣿⡏⠀⠀⠀⠀⠀⠀⢸⣇⣳⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡰⣿⠃⠀⠀⠀⠀⠀⠀⣿⠈⢧⠀
⠀⠘⣿⣿⠁⠀⠀⠀⠀⠀⠀⠘⣿⡛⣶⠀⠀⣠⠔⠒⠛⠒⠦⡀⠀⠀⠀⠀⣠⡤⠶⠤⢤⣀⠀⠀⠀⢀⣏⡄⠀⠀⠀⠀⠀⡀⣿⡆⠈⣧
⣠⡾⠛⣿⣿⣧⠀⠀⠀⠀⢸⣿⠾⢿⡿⠀⣰⠃⠀⠀⠀⠀⠀⢹⡄⠀⠀⡼⠁⠀⠀⠀⠀⠈⠙⣦⠀⢸⣿⡇⣾⣣⡀⠀⢰⣿⣿⣿⣤⠾
⡟⠀⠀⠻⣿⡟⢷⡄⣤⡀⠈⣿⡀⣸⠇⠀⠏⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⡇⢀⡀⠀⠀⠀⠀⢀⡟⠀⠀⠋⣿⣿⣿⡇⣠⣿⠿⠛⢷⡀⠀
⠀⠀⠀⠀⣿⣇⣨⣿⣿⣿⣦⣽⣷⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠁⠀⠀⠃⠀⠙⠢⠤⠤⠴⢾⠀⠀⠀⠀⢸⣷⣿⣿⠟⠁⠀⠀⠈⣧⠀
⠀⠀⠀⠀⠈⠉⠉⠁⠈⠉⠈⢉⣿⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠀⠀⠀⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀⣿⠀
*/

接收控制台传过来的字符串长度和目标子序列数量，注意子序列数量可能超int值，所以需用long来接收。
保存控制台过来的字符串，用大小为2的数组分别存储0、1的数量。
定义左右指针left和right开始滑动窗口寻找符合题意的区间，
我们只需要找一个区间，当找到符合条件的区间时，用resultleft、resultright保存区间左右边界，直接返回即可。
用right滑动窗口，只有在右边界字符为1时，才有可能得到结果，当遍历到1时，res += (left, right)区间中0的个数，
当res大于目标值时，需要持续滑动窗口left，left == ‘0’时，res -= 1的数量，直到res <= target，退出循环。
此时判断res 是否等于target，若等于，说明找到了满足题意的区间，记录区间左右边界并返回、输出。
若遍历完集合还未找到，返回-1。
import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            int n = in.nextInt();
            Long k = in.nextLong();
            char[] chars = in.next().toCharArray();
            int[] zeroAndOne = new int[2];
            int left = 0, right = 0;
            long res = 0;
            int resultleft = 0, resultright = 0;
            for (int i = 0; i < chars.length; i++) {
                if (chars[i] == '1') {
                    res += zeroAndOne[0];
                    zeroAndOne[1]++;
                    while (res > k) {
                        if (chars[left] == '0') {
                            res -= zeroAndOne[1];
                            zeroAndOne[0]--;
                        } else if (chars[left] == '1') {
                            zeroAndOne[1]--;
                        }
                        left++;
                    }
                    if (res == k) {
                        resultleft = left + 1;
                        resultright = i + 1;
                        break;
                    }
                } else {
                    zeroAndOne[0]++;
                }
            }
            if (resultleft != 0 && resultright != 0) {
                System.out.println(resultleft + " " + resultright);
            } else System.out.println(-1);
        }
    }
}

#参考双指针思路
n, k = map(int, input().split())
s = input().strip()

if n == 0:
    print(-1)
    exit()

cnt0 = 0
cnt1 = 0
l = 0
r = 0

# 初始化第一个字符
if s[0] == '0':
    cnt0 += 1
elif s[0] == '1':
    cnt1 += 1

num = 0
result = None

while l < n and r < n:
    if num == k:
        result = (l + 1, r + 1)
        break
    if num < k:
        # 移动右指针
        if r + 1 < n:
            r += 1
            current_char = s[r]
            if current_char == '0':
                cnt0 += 1
            else:
                num += cnt0
                cnt1 += 1
        else:
            # 无法移动右指针时，尝试移动左指针
            current_char = s[l]
            if current_char == '0':
                num -= cnt1
                cnt0 -= 1
            else:
                cnt1 -= 1
            l += 1
    else:
        # 移动左指针
        current_char = s[l]
        if current_char == '0':
            num -= cnt1
            cnt0 -= 1
        else:
            cnt1 -= 1
        l += 1

# 检查退出循环后是否满足条件
if result is None and num == k and l <= r < n:
    result = (l + 1, r + 1)

if result:
    print(result[0], result[1])
else:
    print(-1)