01字符串排列构造算法解析与实现

乱世佳人断佳话

1. 问题背景与定义解析

今天我们来探讨一个有趣的排列构造问题，这个问题来自某知名编程竞赛平台。题目要求我们根据给定的01字符串构造一个特定规则的排列，或者判断其不存在性。这类问题在实际编程面试和算法竞赛中经常出现，考察选手对排列性质的理解和构造能力。

首先明确几个关键概念：

排列：由1到n这n个整数组成的数组，每个整数恰好出现一次。例如n=3时，[1,2,3]、[3,1,2]都是合法的排列。
匹配条件：字符串s与排列p匹配需要满足：
1. 当s[i]='1'时，p的前i+1个元素必须构成一个排列（注意字符串索引从0开始）
2. 当s[i]='0'时，p的前i+1个元素不能构成一个排列

注意：题目中的字符串索引从0开始，而排列长度从1开始计数，这个细节在实际编码时需要特别注意。

2. 问题分析与解题思路

2.1 基本观察

通过分析题目描述和示例，我们可以得出几个关键观察：

前缀排列性：当s[i]='1'时，意味着前i+1个元素必须恰好包含1到i+1的所有整数且不重复。这实际上要求前i+1个元素构成一个排列。
严格递增性：字符串中'1'的出现位置决定了排列必须满足的严格条件。例如，如果s="101"，那么：
- p[0]必须单独构成排列（即必须是1）
- p[0..1]不能构成排列
- p[0..2]必须构成排列
矛盾检测：当s的最后一个字符是'0'时，必然无解，因为整个排列本身必须是一个完整排列（这与s[n-1]='0'矛盾）。

2.2 核心算法思路

基于上述观察，我们可以设计如下算法：

预处理检查：
- 如果s[n-1]='0'，直接返回-1（因为整个排列必须满足排列性质）
- 检查所有'1'位置i，确认i+1是否等于当前最大数字（后面会详细解释）
构造策略：
- 使用双指针或栈结构来匹配'0'和'1'的位置
- 对于连续的'0'和'1'对，进行元素交换以满足条件
- 确保在'1'位置时，前缀确实构成排列
具体实现：
- 初始化一个基础排列[1,2,...,n]
- 遍历字符串，记录需要交换的位置
- 执行必要的交换操作

3. 详细实现与代码解析

3.1 数据结构选择

我们选择以下数据结构来实现算法：

向量(vector)：存储基础排列和最终结果
栈(stack)：用于匹配'0'和'1'的位置对
双数组：记录需要交换的位置索引

3.2 完整代码实现

cpp复制#include <iostream>
#include <vector>
#include <stack>
#include <algorithm>
using namespace std;

int main() {
    int n;
    cin >> n;
    string s;
    cin >> s;
    
    vector<int> a; // 记录'0'的位置
    vector<int> b; // 记录'1'的位置
    stack<int> st; // 用于匹配0和1
    
    // 第一步：匹配0和1的位置
    for(int i = 0; i < n; i++) {
        if(s[i] == '0' && st.empty()) {
            st.push(0);
            a.push_back(i);
        }
        if(s[i] == '1' && !st.empty()) {
            b.push_back(i);
            st.pop();
        }
    }
    
    vector<int> res;
    for(int i = 1; i <= n; i++) {
        res.push_back(i);
    }
    
    // 处理无解情况
    if(a.size() > b.size()) {
        cout << -1;
    } 
    // 无需交换的情况
    else if(a.empty()) {
        for(int i = 0; i < n; i++) {
            cout << res[i] << ' ';
        }
    }
    // 需要交换的情况
    else {
        int cnt = a.size();
        for(int i = 0; i < cnt; i++) {
            swap(res[a[i]], res[b[i]]);
        }
        for(int i = 0; i < n; i++) {
            cout << res[i] << ' ';
        }
    }
    
    return 0;
}

3.3 代码关键点解析

位置匹配：使用栈来匹配'0'和'1'的位置。遇到'0'入栈，遇到'1'出栈，确保每个'0'都能找到对应的'1'。
交换策略：在基础排列上，交换匹配的'0'和'1'位置的元素。这样做的目的是：
- 在'0'位置时，前缀不构成排列
- 在'1'位置时，前缀恰好构成排列
边界处理：
- 如果'0'比'1'多，说明无法完全匹配，返回-1
- 如果没有需要交换的位置，直接输出基础排列

4. 算法正确性证明

为了验证我们算法的正确性，我们需要证明：

充分性：构造的排列满足所有条件
- 对于每个'1'位置i，前i+1个元素确实构成排列
- 对于每个'0'位置j，前j+1个元素不构成排列
必要性：如果问题无解，算法确实能返回-1
- 特别是当s[n-1]='0'时
- 或者当'0'和'1'无法完全匹配时

通过示例分析可以验证这一点：

示例1：s="001"
- 匹配两个'0'和一个'1'
- 交换位置0和2的元素：[1,2,3] → [3,2,1]
- 验证：
  - p[0]=3，不是排列（满足s[0]='0'）
  - p[0..1]=[3,2]，不是排列（满足s[1]='0'）
  - p[0..2]=[3,2,1]，是排列（满足s[2]='1'）
示例2：s="1110"
- 最后一个字符是'0'，直接返回-1