SPOJ 1421 - Goods（置换）

最新推荐文章于 2019-12-14 20:03:59 发布

原创最新推荐文章于 2019-12-14 20:03:59 发布 · 873 阅读

0 ·

CC 4.0 BY-SA版权

博弈+概率+置换专栏收录该内容

6 篇文章

订阅专栏

本文深入探讨了一种特定排列问题的解决方案，即通过最少的交换次数将任意给定的排列转换为从1到n的递增排列。文章详细介绍了寻找所有循环节的方法，并解释了如何利用这些循环节来计算所需的交换次数。重点在于证明长度为2的循环节只需一次交换，而其他循环节则需通过连接形成链状结构并进行两次交换即可实现目标排列。

题意：一个1到n的排列，可以对两个数字进行交换，每轮可进行多次交换，但是每个数字每轮只能交换一次，问几轮才能把排列变成从1，2，3...，n的排列

思路：找出所有的循环节，长度为2的循环节只需要进行一次，剩下的则需要两次

证明：长度为2的循环节只进行一次交换显而易见，而剩下的可以拉成一条链的形式（将排列与1,2,3，...，n的排列连线），如果把这条链由两头向中间依次交换（即第i个与第k+1-i个进行交换），则会打破原来交叉的链，也就是分解了循环节，交叉的链最长为2，所以只需要两次就OK了

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;

int A[5010];
int F[5010];
int t[5010];
int vis[5010];
int ct,ans,d[5010][2];

int dfs(int x)
{
    t[++ct]=A[x];
    if(!vis[A[x]])
    {
        vis[A[x]]=1;
        dfs(A[x]);
    }
}

int check(int n)
{
    for(int i=1; i<=n; i++)
    {
        if(i!=A[i])return 0;
    }
    return 1;
}

int solve(int n)
{
    int f=0;
    memset(vis,0,sizeof(vis));
    for(int i=1; i<=n; i++)
    {
        if(!vis[i])
        {
            ct=0;
            vis[i]=1;
            dfs(i);
            if(ct>2)f=1;
            if(ct>=2)
            {
                for(int j=1; j<=ct/2; j++)
                {
                    d[ans][0]=t[j];
                    d[ans][1]=t[ct+1-j];
                    ans++;
                    swap(A[F[t[j]]],A[F[t[ct+1-j]]]);
                    swap(F[t[j]],F[t[ct+1-j]]);
                }
            }
        }
    }
    if(!f)
    return 0;
    else
    return 1;
}

int main()
{
    int n,f=0;
    scanf("%d",&n);
    for(int i=1; i<=n; i++)
    {
        scanf("%d",&A[i]);
        F[A[i]]=i;
    }
    ans=0;
    if(check(n))
    {
        printf("0\n");
    }
    else
    {
        if(!solve(n))
        {
            printf("1\n%d",ans);
            for(int i=0;i<ans;i++)
                printf(" %d-%d",d[i][0],d[i][1]);
            printf("\n");
        }
        else
        {
            printf("2\n%d",ans);
            for(int i=0;i<ans;i++)
                printf(" %d-%d",d[i][0],d[i][1]);
            printf("\n");
            ans=0;
            solve(n);
            printf("%d",ans);
            for(int i=0;i<ans;i++)
                printf(" %d-%d",d[i][0],d[i][1]);
            printf("\n");
        }
    }
    return 0;
}