普及- 题单

题号	点击这里跳转/类型
p1030 求先序排列	Here/树
P1109 学生分组	Here/贪心
P1706 全排列问题	Here/递归
P1223 排队接水	Here/贪心
P1459 三值的排序	Here/贪心
P1969 积木大赛	Here/贪心
P2695 骑士的工作	Here/排序、贪心
P1996 约瑟夫问题	Here/模拟，链表
P1165 日志分析	Here/模拟，高性能
Subsequence	Here/尺取法

P1030 求先序排列

题目描述
给出一棵二叉树的中序与后序排列。求出它的先序排列。（约定树结点用不同的大写字母表示，长度 ≤8）。

利用中序和后序的顺序求出前序遍历，可以联系，利用前序和中序的方法反向使用，前序遍历顺序 根左右，而后序遍历顺序则是左右根，反向直接跑出前序遍历。

#include <iostream>
#include <string>
using namespace std;
char pre[10], ino[10], pos[10];
int k, backcount, pss;
string mid, last;

void rec(int l, int r) {
    if (l >= r)
        return;
    char root = pos[--backcount];  //做如同前序的顺序，根左右遍历
    int loc = 0;
    //找到在中序的位置，记录loc
    for (int i = 0; i < mid.length(); ++i)
        if (mid[i] == root) {
            loc = i;
            break;
        }
        //在这里，优先建立右子树，因为后序遍历是左右根，倒序是根右左，所有优先继续往右
    rec(loc + 1, r);
    rec(l, loc);
    //输出的时候也是根右左，所以需要反向存储
    pre[--pss] = root;
}

int main() {
    cin >> mid >> last;
    for (int i = 0; i < mid.length(); ++i) {
        ino[i] = mid[i];
        pos[i] = last[i];
    }
    backcount = pss = last.length();
    rec(0, mid.length());
    for (int i = 0; i < mid.length(); ++i)
        cout << pre[i];
    cout << endl;
    return 0;
}

P1109 学生分组
题目描述
有N组学生，给出初始时每组中的学生个数，再给出每组学生人数的上界R和下界L(L≤R)，每次你可以在某组中选出一个学生把他安排到另外一组中，问最少要多少次才可以使N组学生的人数都在[L,R]中。

贪心法，超出做大限度的累计，以及未达到的累计，最少步数就是将多的移到少的地方，注意先考虑不是-1的情况，因为这种情况下保证是能够移动成符合要求的，因此，要选择最大的那个，填满或者消去，这是必须要做的，而利用贪心做到这就已经是最少的步数了
再判断-1的情况，当组数×最大的人数＜当前总人数或者组数×最小的人数>当前总人数 的时候就是-1

#include <algorithm>
#include <iostream>
using namespace std;
int n, peo[55], up, down, pluss, sub, sum;
int main() {
    cin >> n;
    for (int i = 0; i < n; ++i)
        cin >> peo[i];
    cin >> down >> up;
    for (int i = 0; i < n; ++i) {
        sum += peo[i];
        if (peo[i] < down) {
            sub += down - peo[i];
        } else if (peo[i] > up) {
            pluss += peo[i] - up;
        }
    }
    if (n * up < sum || n * down > sum)
        cout << -1 << endl;
    else
        cout << max(sub, pluss);
    return 0;
}

P1706 全排列问题
简单全排列，dfs基础回忆

#include <iomanip>
#include <iostream>
using namespace std;
bool f[10];
int show[10];
int n;
void dfs(int num) {
    if (num == n + 1) {
        for (int i = 1; i <= n; ++i)
            cout << setw(5) << right << show[i];
        cout << endl;
        return;
    }
    for (int i = 1; i <= n; ++i) {
        if (f[i])
            continue;
        show[num] = i;
        f[i] = true;
        dfs(num + 1);
        f[i] = false;
    }
}

int main() {
    cin >> n;
    dfs(1);
    return 0;
}

P1223 排队接水
该题较简单，为了使平均等待时间最短，那么接水时间越少的人应该要排前面，而等待的人是不包括其本人的，所以人数要-1人。
顺序问题可以直接快排即可。
最后输出平均值，好在这题不会爆数据。

#include <algorithm>
#include <iomanip>
#include <iostream>
using namespace std;
int n;
double sum, ave;
struct p {
    double data;
    int No;
} D[1005];

bool cmp(p &a, p &b) {
    if (a.data != b.data)
        return a.data < b.data;
    else
        return a.No < b.No;
}

int main() {
    cin >> n;
    for (int i = 0; i < n; ++i) {
        cin >> D[i].data;
        D[i].No = i + 1;
    }
    sort(D, D + n, cmp);
    for (int i = 0; i < n; ++i) {
        sum += (D[i].data * (n - i - 1));
        //当前是不需要再等待了，所以是n-i-1个人的等待时间
    }
    ave = sum / n;
    for (int i = 0; i < n; ++i)
        if (i == 0)
            cout << D[i].No;
        else
            cout << ' ' << D[i].No;
    cout << endl;
    cout << fixed << setprecision(2) << ave << endl;
    return 0;
}

P1459 -USACO2.1- 三值的排序 Sorting a Three-Valued Sequence
升序排列，求交换次数最少，在这里只有1-3,3个数值。
分三块区间，分别就是1，2，3区间；交换次数最少，则是该区间直接与另一区间对应数值交换即可。
在这里二维数组记录出现个数，交换之后要互相减去，最后只需要扫描区间1里面还有没有2或3 出现的数值，多试验几次就可以发现，之前只要是匹配的，最后得到的要么已经全部归位，要么剩余2步才能交换好，因为是需要3个数字交换的。

#include <algorithm>
#include <iostream>
using namespace std;
int n, Data[1005], cmps[1005];
int dry[4][4];
int main() {
    cin >> n;
    //备份一份，Data用于排序，cmps用于比较
    for (int i = 0; i < n; ++i) {
        cin >> Data[i];
        cmps[i] = Data[i];
    }

    sort(Data, Data + n);
    //如果cmps的数值不是在这个区间上的数，
    //那么这个区间上标记一个这样的数
    for (int i = 0; i < n; ++i) {
        if (cmps[i] != Data[i]) {
            ++dry[Data[i]][cmps[i]];
        }
    }
    int step;
    step = 0;
    //开始循环遍历三个分区，是0就跳过
    for (int i = 1; i <= 3; ++i) {
        for (int j = 1; j <= 3; ++j) {
            if (dry[i][j] == 0)
                continue;
            else {
            //不是0，则需要交换，最好能直接与对应分区交换，
            //因此寻找最小，不要忘记减去了
                int mini = min(dry[i][j], dry[j][i]);
                step += mini;
                dry[i][j] -= mini;
                dry[j][i] -= mini;
            }
        }
    }
//最后剩下的就是不能1步交换到位的，需要交换2次，而事实规律一定是留下区间内的1个有效数字
    for (int i = 1; i <= 1;++i){
        for (int j = 2; j <= 3;++j){
            if(dry[i][j]!=0){
                step += dry[i][j] * 2;
                break;
            }
        }
    }
    cout << step << endl;
    return 0;
}

P1969 积木大赛
只需要比较前面的积木高度，如果比它高，则只需要再加上他们的差值；如果比它低，说明可以被覆盖；

#include <algorithm>
#include <iostream>
using namespace std;
int n, step, Data[100005];

int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    cin >> n;
    for (int i = 1; i <= n; ++i) {
        cin >> Data[i];
        step += Data[i] - min(Data[i - 1], Data[i]);
    }
    cout << step << endl;
    return 0;
}

P2695 骑士的工作
模拟，用最小的费用砍能砍下的头，都先排序，小能力砍小头，使当前费用最大化利益。

#include <algorithm>
#include <iostream>
#include <set>
using namespace std;
int head, knight, Head[20005], Data[20005];
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    int p;
    cin >> head >> knight;
    for (int i = 0; i < head; ++i)
        cin >> Head[i];
    for (int i = 0; i < knight; ++i)
        cin >> Data[i];
//之前是想的做法有点错误，
//但是未考虑到骑士能力小头累加起来有可能大于怪物总头大小
    if (head > knight) {
        cout << "you died!" << endl;
    } else {
        int price = 0;
        sort(Head, Head + head);
        sort(Data, Data + knight);
        int index = 0;
        for (int i = 0; i < knight; ++i) {
            if (Data[i] >= Head[index]) {
                price += Data[i];
                ++index;
            }
            if (index == head)
                break;
        }
        if (index < head)
            cout << "you died!" << endl;
        else
            cout << price << endl;
    }
    return 0;
}

P1996 约瑟夫问题
题目很简单，考察数据结构，这里使用的是双向循环链表，比较方便循环。
当然也可以用队列的方式等等。

#include <cstdlib>
#include <iostream>
using namespace std;
int n, k;
struct Node {
    int Data;
    Node *BEFORE, *NEXT;//前，后结点
};

int main() {
    cin >> n >> k;
    Node *DList = new Node, *cur = DList;
    //一开始的第一个数据设置
    DList->Data = 1;
    DList->BEFORE = NULL;
    DList->NEXT = NULL;

    for (int i = 2; i < n + 1; ++i) {
        Node *Cnode = new Node;
        Cnode->BEFORE = cur;
        Cnode->NEXT = DList;
        Cnode->Data = i;
//规划好，当前结点的前后指针指向谁，第一个结点前指针谁谁，前一个结点的后指针指谁谁
        cur->NEXT = Cnode;
        DList->BEFORE = Cnode;

        cur = cur->NEXT;
    }

    int sum = n;
    Node *T = DList;
    while (sum) {
        for (int times = 0; times < k - 1; ++times)
            T = T->NEXT;

        cout << T->Data << ' ';
//后面结点，前面结点的前后需要变动
        T->NEXT->BEFORE = T->BEFORE;
        T->BEFORE->NEXT = T->NEXT;
//删去该结点，并让总数-1
        Node *dd = T;
        T = T->NEXT;
        delete dd;

        --sum;
    }
    return 0;
}

P1165 日志分析
模拟栈操作，输出只需要查询最大的元素，如果是线性查找是肯定不够的，通过一个数组记录最大值即可

#include <algorithm>
#include <iostream>
using namespace std;
int n, top, statues, STACK[200005];
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    cin >> n;
    int p;
    top = 0;
    while (n--) {
        cin >> statues;
        if (statues == 0) {
            cin >> p;
            ++top;
            STACK[top] = max(STACK[top - 1], p);
        } else if (statues == 1) {
            if (top == 0)
                continue;
            --top;
        } else
            cout << STACK[top] << endl;
    }
    return 0;
}

POJ 3061 Subsequence

普通解法

#include <algorithm>
#include <iostream>
using namespace std;
const int Max_n = 100000;
int T, n, Need, temp[Max_n], sum[Max_n + 1];

void solve() {
    for (int i = 0; i < n; ++i)
        sum[i + 1] = temp[i] + sum[i];

    if (sum[n] < Need) {
        cout << 0 << endl;
        return;
    }

    int res = n;
    //t 二分搜索得到
    for (int s = 0; sum[s] + Need <= sum[n]; ++s) {
        int t = lower_bound(sum + s, sum + n, sum[s] + Need) - sum;
        res = min(res, t - s);
    }
    cout << res << endl;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    cin >> T;
    while (T--) {
        cin >> n >> Need;
        for (int i = 0; i < n; ++i) {
            cin >> temp[i];
        }
        solve();
    }
    return 0;
}

尺取法

1.将TS，TE，sum 设置为0
2.不断增加D[TE]，使sum>=NEED
3.如果无法满足，则终止，否则更新
4.将sum-D[TS]，并将TS往后调

#include <algorithm>
#include <iostream>
using namespace std;
const int Max_n = 100005;
int D[Max_n], n, T, NEED, TS, TE, sum;

void solve() {
    TS = TE = sum = 0;
    int res = n;
    for (;;) {
        while (sum < NEED && TE < n) {
            sum += D[TE++];
        }
        if (sum < NEED)
            break;
        res = min(res, TE - TS);
        sum -= D[TS++];
    }
    if (res > n)
        res = 0;
    cout << res << endl;
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    cin >> T;
    while (T--) {
        cin >> n >> NEED;
        for (int i = 0; i < n; ++i)
            cin >> D[i];

        solve();
    }
    return 0;
}