codeforces 432C Prime Swaps

http://codeforces.com/problemset/problem/432/C

题目大意：

给你一个数组a[n]，其中有 1-n 这些数，但是 a[i] 的位置上不一定是 i，你所要做的就是把 i 通过两个数两两交换 放到a[i] 的位置上，两数要交换的条件得满足下标之差加一是一个质数。其中交换的次数要小于 5 * n。

由于题目并没有说要求最优解，只要求小于 5 * n，那么就可以考虑从第一个数开始调整，一直到最后一个数，每次交换后面的数，这样就影响到前面的已经调整好的数，同时，如果每个交换的次数小于等于5，那么总的肯定小于 5 * n。

想到哥德巴赫猜想，大于2的偶数都可以表示为两个质数相加，然后自然而然的想到了奇数减个3的话，用三个数表示就可以了。接下来需要的就是用素数筛筛出素数来，然后分解需要交换的距离就行了。

首先先考虑拆分成两个数相加的情况需要交换的地方对应的下标分别为i，j， k，且i < j < k ，i和j之间相隔 x1 - 1， j与k之间相隔 x2 - 1，i与j相隔dist - 1，所以 x1 + x2 = dist + 1，所以当dist为奇数的时候，dist+1就是偶数了，然后x1和x2就可以直接拆分出来了。当时当dist为偶数的时候，dist+1 为奇数那么就需要拆分成三个质数了，和这里的考虑的情况不同。

接下来考虑拆分成三个质数的情况，需要交换的地方对应的下标为i，j，k，p，且i < j < k < p，i和j之间相隔x1 - 1，j和k之间相隔x2 - 1，k和p之间相隔x3 - 1，i和p之间相隔dist - 1，所以x1 + x2 + x3 = dist + 2，所以当dist为偶数的时候dist + 2也是偶数，我们这里不妨假设先拆出一个2，然后就只需要拆分dist这个偶数就行了，如果这里先拆了大于2的素数，肯定是不行的，因为2是最大的偶数加质数，如果用更大的质数 n1 ，就会导致dist + 2 - n1是奇数，这样还得再次拆开，不行。

所以当初的想法还是有点问题的，这边只需要拆分偶数就行了。还有一个问题是，交换后那些用来辅助的地方的值是否要和原来一样呢，不知道那种情况更优，想了想这个和数据有关吧，最后还是没有改变那些值。接下来上代码。

#include<cmath>
#include<queue>
#include<cstring>
#include<iostream>
using namespace std;
const int MAXN = 100000 + 10005;

class SwapIndex
{
public:
    int s;
    int e;

    void setValue(int s, int e)
    {
        this->s = s;
        this->e = e;
    }
};

int a[MAXN];
//用_a[]记录需要交换的值对应的下标
int _a[MAXN];
bool vis[MAXN];
SwapIndex temp;
//记录需要交换的下标
queue<SwapIndex> swapIndex;

void Swap(int x, int y)
{
    a[x] ^= a[y];
    a[y] ^= a[x];
    a[x] ^= a[y];
    temp.setValue(x, y);
    swapIndex.push(temp);
}

//素数筛筛素数，vis[质数] = false;
void sieve(int n)
{
    int m = (int)sqrt(n + 0.5);
    memset(vis, false, sizeof(vis));

    for(int i = 2; i <= m; ++ i)
        if(vis[i] == false)
            for(int j = i * i; j <= n; j += i)
                vis[j] = true;
}

//划分偶数n为两个质数，x为较小的素数
void divide(int n, int &x)
{
    if(n == 4)
    {
        x = 2;
        return;
    }

    for(int i = (n >> 1) | 1; i < n; i += 2)
        if(vis[i] == false && vis[n - i] == false)
        {
            x = n - i;
            return;
        }
}

int main()
{
    cin.sync_with_stdio(false);
    sieve(MAXN);
    int n;
    int x1, x2, x3;

    while(cin >> n)
    {
        for(int i = 1; i <= n; ++i)
        {
            cin >> a[i];
            _a[ a[i] ] = i;
        }

        for(int i = 1; i <= n; ++i)
            if(a[i] != i)
            {
                int dist = _a[i] - i + 1;
                //修正交换后导致_a[]的改变
                _a[ a[i] ] = _a[i];

                if(vis[dist] == false)
                    Swap(i, _a[i]);
                else
                {
                    if(dist & 1)
                    {
                        divide(dist + 1, x1);
                        x1 = i + x1 - 1;
                        x2 = i + dist - 1;
                        //保证只交换了相应位置
                        Swap(x1, x2);
                        Swap(i, x1);
                        Swap(x1, x2);
                    }
                    else
                    {
                        x1 = i + 2 - 1;
                        divide(dist, x2);
                        x2 = x1 + x2 - 1;
                        x3 = i + dist - 1;
                        //保证只交换了相应位置
                        Swap(x2, x3);
                        Swap(x1, x2);
                        Swap(i, x1);
                        Swap(x1, x2);
                        Swap(x2, x3);
                    }
                }
            }

        cout << swapIndex.size() << endl;

        while(swapIndex.size())
        {
            temp = swapIndex.front();
            cout << temp.s << ' ' << temp.e << endl;
            swapIndex.pop();
        }
    }

    return 0;
}