1937. OverCooked! 2 -- constructive algorithms,divide and conquer

 

 

 

 

#include <bits/stdc++.h>
//分块法
using namespace std;

template <class T>/*模板，表示给一个未排序的数组排序后对应的下标*/
vector<int> make_index(const vector<T>& a, int start_id) {
    int n = a.size();
    vector<pair<T, int> > t(n);
    for (int i = 0; i < n; i++) {
        t[i] = make_pair(a[i], i);/*先给一个初始下标*/
    }
    sort(t.begin(), t.end());/*排序一波*/
    vector<int> id(n);
    for (int i = 0; i < n; i++) {
        id[t[i].second] = start_id + i;/*排序后的真实下标返回*/
    }
    return id;
}

int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    int n; cin >> n;
    vector<int> s(n);
    queue<int> q;
    for (int& x : s) cin >> x;/*新方法，引用地遍历，输入就能实际地改变参数，成功输入*/
    s = make_index(s, 0);/*从下标0开始给id*/
    /*lambda函数：auto 函数名  = [捕获方式]{lambda表达式}*/
    /*用途：书写小型函数,快速使用*/
    auto in = [&] { cout << "+"; q.push(s.back()); s.pop_back(); };
    auto out = [&] { cout << "-"; s.push_back(q.front()); q.pop(); };
    while (s.size()) in();/*in表示入队*/
    int K = ceil(sqrt(n)), not_sorted = n;/*K表示分成的每一段的长度*/
    while (not_sorted) {
        int k = min(K, not_sorted);/*取(K和没排过的数目)的最小值，防止越界*/
        int L = n - not_sorted, R = L + k - 1;
        for (int i = 0; i < not_sorted; i++) {
            if (q.front() >= L && q.front() <= R) {//排序后下标在[L,R]这段区间里
                out();//出队
                in();//入队
            }
            else {//不在
                out();//出队
            }
        }
        for (int i = R; i >= L; i--) {
            int sz = q.size();
            for (int j = 0; j < sz; j++) {
                if (q.front() == i) {
                    out();/*对应的下标符合，出队，入栈*/
                }
                else {/*否则回到队伍*/
                    out();
                    in();
                }
            }
        }
        for (int i = 0; i < not_sorted; i++) in();/*没排的再入队*/
        for (int i = 0; i < k; i++) out();/*排好的出队，放入堆栈*/
        not_sorted -= k;
    }
    cout << "!\n";
    return 0;
}

 

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
typedef pair<int, int> pii;
pii arr[maxn];
stack<pii> st;
queue<pii> qu;

int main() {
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &arr[i].first);//值放first
        arr[i].second = i;//下标放在second
        st.push(arr[i]);
    }
    sort(arr + 1, arr + n + 1);//排序，得到排序后应该的样子
    int jg = n;
    for (int i = 1; i <= n; i++) {
        printf("+");
        qu.push(st.top());
        st.pop();
    }
    queue<pii> interval;//interval:间隔,区间
    int maax = 1;
    /*
             一个队列加一个栈，实现快速排序
        方式：手动的 模拟函数栈的堆栈弹栈的过程
        
    */
    interval.push({ 1, n });//(1,n)的堆栈
    while (maax) {
        pii tmp;
        maax = 0;//当长度无法更新为比0更大，即表明排序完成，退出外循环
        do {
            tmp = interval.front();//取最上层的堆栈
            interval.pop();//弹栈
            int le = tmp.first, ri = tmp.second;//left,right端点
            int mid = (le + ri) >> 1;//中点
            maax = max(maax, ri - le);//更新区间最大长度
            if (le != ri) {//端点不meet
                interval.push({ le, mid });//左半边堆栈
                interval.push({ mid + 1, ri });//右半边堆栈
                pii x = arr[mid];//pivot值
                pii y;
                int cnt = 0;
                for (int i = le; i <= ri; i++) {
                    y = qu.front();
                    printf("-");//不管怎么样先push回到stack
                    if (y > x) {/*比较大的数先呆在stack里*/
                        qu.pop();
                        st.push(y);
                        cnt++;
                    }
                    else {/*比较小的数重新push回队列*/
                        printf("+");
                        qu.pop();
                        qu.push(y);
                    }
                }
                while (cnt--) {/*stack里刚才放的数取出来push进队列里*/
                    y = st.top();
                    st.pop();
                    qu.push(y);
                    printf("+");
                }
            }
            else {//如果左端点右端点meet
                interval.push({ le, ri });
                qu.push(qu.front());
                qu.pop();
                printf("-+");//一去一回，回到队列中,完成排序动作
            }
        } while (tmp.second != n);//当没有排到第n个数，就继续分治
    }
    for (int i = 1; i <= n; i++) {//队列里的数返回stack中即可
        printf("-");
        qu.pop();
    }
    printf("!");//华丽结束
    return 0;
}

 

#include <bits/stdc++.h>
/*二进制基数解法*/
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin >> n;
    vector<int> s(n);
    queue<int> q;
    for (int& x : s) cin >> x;
    auto in = [&] {
        cout << "+";
        q.push(s.back());
        s.pop_back();
    };
    auto out = [&] {
        cout << "-";
        s.push_back(q.front());
        q.pop();
    };
    while (s.size()) in();
    int mask = 0;
    for (int j = 19; j >= 0; j--) {
        mask |= (1 << (j + 1));
        int y = 0;
        for (int i = 0; i < n; i++) {
            int x = q.front();
            if (i > 0 && (x & mask) != (y & mask)) {
                while (s.size()) in();
            }
            y = x;
            out();
            if (!((x >> j) & 1)) in();
        }
        while (s.size()) in();
    }
    while (q.size()) out();
    cout << "!\n";
    return 0;
}