题意：

一个序列长为n，初始为1......n，m种操作，每次翻转一个区间，问操作k次后满足a[i]==i的个数，当操作数大于m时，从第一种操作开始循环反复进行那m种操作，直到操作k次。

题解：

m最大只有10，我们将k分解成k=p*m+q

对于位置y，假设在操作q次后出现在位置x，那么位置x只有经过p*m次操作后出现在位置y，才能保证再操作q次后，回到位置x。

对于位置x，我们以m次操作为一轮，求出x的循环节，设为L，那么x变为y的首要条件就是他们俩在同一个循环节中。

假设他们俩在同一个循环节中，设x和y在循环节中距离为d，显然，只有满足p=a*L+d，才能满足经过p轮，x恰好出现在位置y。

以上是核心思想，难在如何统计答案。

首先，我们可以O（n）地求出所有点的循环节和他们在那个循环中的位置（为以后算同一循环节中的两点的距离用）。

将n个位置安装循环节的长度从小到大排序。

将询问按照%m的值分为m组，每组分别计算，这样做的好处是q相同，可以知道每个位置经过p*m次操作的目标位置。

每组求解时，我们再以循环节长度划分，相同循环节长度的在一起求解。

为什么？

因为统计答案用到p%L（即上文说的d），而L的种类数不超过sqrt（n）种，统计时需要一个数组，记录不同d的出现次数，每到一个不同的L，数组都要清零一次，所以最坏清零sqrt（n）次，才能满足时限。

具体见代码。

 

代码:

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#define N 100010
#define mod 1000000007
#define INF 1e17
#define eps 1e-10
#define pi 3.141592653589793
#define LL unsigned long long
#define pb push_back
#define cl clear
#define si size
#define lb lowwer_bound
#define mem(x) memset(x,0,sizeof x)
#define sc(x) scanf("%d",&x)
#define scc(x,y) scanf("%d%d",&x,&y)
#define sccc(x,y,z) scanf("%d%d%d",&x,&y,&z)
using namespace std;

bool vis[N];
int que[N],cr[N],fa[N],ds[N],d[N],ans[N],a[11][N],n,m,q,tot;

struct node
{
    int u,id;
    bool operator < (const node z) const
    {
        return u<z.u;
    }
}w[N];

vector<node>Q[10];

void TAT(int x)
{
    int cnt=0; tot++;
    for (int i=x;!vis[i];i=a[m][i])
    {
        vis[i]=1;
        que[++cnt]=i;
        ds[i]=cnt;
    }
    for (int i=1;i<=cnt;i++)
    {
        cr[que[i]]=cnt;
        fa[que[i]]=tot;
    }
}

int main()
{
    while(~sccc(n,m,q))
    {
        for (int i=1;i<=n;i++) a[0][i]=i;
        for (int i=1;i<=m;i++)
        {
            int x,y; scc(x,y);
            reverse(a[0]+x,a[0]+y+1);
            for (int j=1;j<=n;j++) a[i][a[0][j]]=j;
        }
        mem(vis); mem(ans); mem(Q); tot=0;
        for (int i=1;i<=n;i++) if (!vis[i]) TAT(i);
        for (int i=1;i<=n;i++) w[i]=node{cr[i],i};
        sort(w+1,w+n+1);
        for (int i=1;i<=q;i++)
        {
            int x; sc(x);
            Q[x%m].pb(node{x/m,i});
        }
        for (int i=1;i<=n;i++) a[0][i]=i;
        for (int i=0;i<m;i++) if (Q[i].size())
        {
            for (int j=1;j<=n;j++) que[a[i][j]]=j;
            for (int j=1;j<=n;j++)
            {
                if (j==1 || w[j].u!=w[j-1].u) mem(d);
                int x=que[w[j].id];
                if (fa[x]==fa[w[j].id])
                {
                    int k=(ds[x]+cr[x]-ds[w[j].id])%cr[x];
                    d[k]++;
                }
                if (j==n || w[j].u!=w[j+1].u)
                {
                    for (int k=0;k<Q[i].size();k++)
                        ans[Q[i][k].id]+=d[Q[i][k].u%w[j].u];
                }
            }
        }
        for (int i=1;i<=q;i++) printf("%d\n",ans[i]);
    }
}