UVa 12174 - Shuffle

链接：

https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=3326

 

题意：

你正在使用的音乐播放器有一个所谓的乱序功能，即随机打乱歌曲的播放顺序。
假设一共有s首歌，则一开始会给这s首歌随机排序，全部播放完毕后再重新随机排序、继续播放，依此类推。
注意，当s首歌播放完毕之前不会重新排序。这样，播放记录里的每s首歌都是1～s的一个排列。
给出一个长度为n（1≤s，n≤100000）的播放记录（不一定是从最开始记录的），你的任务是统计下次随机排序所发生的时间有多少种可能性。
例如，s=4，播放记录是3, 4, 4, 1, 3, 2, 1, 2, 3, 4，不难发现只有一种可能性：前两首是一个段的最后两首歌，后面是两个完整的段，因此答案是1；
当s=3时，播放记录1, 2, 1有两种可能：第一首是一个段，后两首是另一段；前两首是一段，最后一首是另一段。答案为2。

 

分析1：

使用滑动窗口，窗口大小是“基本”固定的（因为还需要考虑不完整的段），因此只需要一个指针；
而且所有数都是1～s的整数，只需要一个数组即可保存每个数在窗口中出现的次数。
再用一个变量记录在窗口中恰好出现一次的数的个数，则可以在O(n)时间内判断出每个窗口是否满足要求（每个整数最多出现一次）。
这样，就可以枚举所有可能的答案，判断它对应的所有窗口，当且仅当所有窗口均满足要求时这个答案是可行的。
可以把所有窗口都映射成窗口0 ~ s-1，使用求模即可。

 

代码1：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int UP = 100000 + 5;

int a[UP], num[UP]; //num[x]记录当前窗口中x值的个数
bool can[UP]; //can[i]表示以位置i结尾的一个序列是否可能是1~s的一个排列

int main(){
    int T;
    scanf("%d", &T);
    while(T--){
        int s, n;
        scanf("%d%d", &s, &n);
        for(int i = 0; i < n; i++) scanf("%d", &a[i]);

        memset(num, 0, sizeof(num));
        memset(can, true, sizeof(can));

        int tot = 0; //tot记录当前窗口中只出现一次的数的个数
        for(int i = 0; i < n + s; i++){
            if(i < n && ++num[a[i]] == 1) tot++;
            if(i >= s && --num[a[i-s]] == 0) tot--;
            if(min(i, n-1) - max(i-s, -1) != tot) can[i%s] = false;
        }

        int ans = 0;
        for(int i = 0; i < s; i++) if(can[i]) ans++;
        printf("%d\n", ans);
    }
    return 0;
}

 

分析2：

这个比较直观。对于1 2 1这样的播放列表，两个1之间必然存在一个窗口的交界位置。类似地，对于同一个数字的两次相邻的出现，
都能排除一些不可能的位置，当把所有不可能的位置排除后，剩下的位置个数便是答案。
可以把所有位置都映射成位置0 ~ s-1，使用求模即可。

 

代码2：

#include <cstdio>
#include <cstring>

const int UP = 100000 + 5;

int a[UP], f[UP]; //f[a[i]] 记录与 a[i] 的值相同的前一个位置
bool can[UP]; //can[i]表示以位置i结尾的一个序列是否可能是1~s的一个排列

int main(){
    int T;
    scanf("%d", &T);
    while(T--){
        int s, n;
        scanf("%d%d", &s, &n);
        for(int i = 0; i < n; i++) scanf("%d", &a[i]);

        memset(f, -1, sizeof(f));
        memset(can, true, sizeof(can));

        for(int x, i = 0; i < n; f[x] = i++){
            x = a[i];
            if(f[x] != -1){ //判断x之前是否出现过
                if(i - f[x] >= s) continue; //相邻的两个x的距离不小于s，则位置f[x]~i-1都可能是结尾
                int L = f[x] % s, R = i % s; //把位置L和R都映射成位置0 ~ s-1
                if(L < R){
                    for(int t = 0; t < L; t++) can[t] = false;
                    for(int t = R; t < s; t++) can[t] = false;
                }
                else for(int t = R; t < L; t++) can[t] = false;
            }
        }

        int ans = 0;
        for(int i = 0; i < s; i++) if(can[i]) ans++;
        printf("%d\n", ans);
    }
    return 0;
}

 

分析3：

这是我自己想到的做法，跟分析2基本相同，只是没有使用求模来映射位置，速度要慢一点。在这里也把代码贴一下吧。

 

代码3：

#include <cstdio>
#include <cstring>

const int UP = 100000 + 5;

int a[UP], f[UP]; //f[a[i]] 记录与 a[i] 的值相同的前一个位置
bool no[UP*2]; //no[i]表示以位置i结尾的一个序列是否可能是1~s的一个排列

int main(){
    int T;
    scanf("%d", &T);
    while(T--){
        int s, n;
        scanf("%d%d", &s, &n);
        for(int i = 1; i <= n; i++) scanf("%d", &a[i]);

        memset(f, 0, sizeof(f));
        memset(no, false, sizeof(no));

        for(int x, i = 1; i <= n; f[x] = i++){
            x = a[i];
            if(f[x]){ //判断x之前是否出现过
                if(i - f[x] >= s) continue; //相邻的两个x的距离不小于s，则位置f[x]~i-1都可能是结尾
                for(int t = i; t - f[x] < s; t++) no[t] = true; //排除不可能是结尾的位置
                for(int t = f[x] - 1; t && i - t <= s; t--) no[t] = true;
            }
        }

        int ans = 0;
        for(int t, i = 1; i <= s; i++){
            for(t = i; t <= n + s; t += s) if(no[t]) break; //判断以位置i为结尾是否可行
            if(t > n + s) ans++;
        }
        printf("%d\n", ans);
    }
    return 0;
}