poj3590——置换+dp

题目链接：poj.org/problem?id=3590

题目翻译：

对每一个置换T，都存在一个 T^k=e. 现在让你求一个n元置换，使得它的阶最大，即当T^k=e时，k最大。若同时存在多个这样的T，那么输出其中排序最小的。

题解：

由于每一个置换都可以分解成若干个循环，那么这些循环的阶的最小公倍数就是该置换的阶。

要想让整个置换的k最大,就是要保证置换里的每个循环节的长度之间的lcm最大 。

因此这个问题可以转换成：

给一个整数n，保证n1+n2+n3```+ni = n，并且n1,n2,```ni的最小公倍数最大。

求出对应的n1,n2,n3,n4...ni的最小排序和最大的最小公倍数。

最大的最小公倍数好求，我们可以直接dp做，代码里面有详解。

剩下的就是怎么保证顺序最小了。

对求出的maxlcm进行质因子幂分解，每个因子都是一段循环节的长度，因为因子的和小于等于n，所以多余的当成一阶循环输出。

证明可以参考：https://blog.csdn.net/tsaid/article/details/7389140

#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
#define rp(i,s, t) for (i = s; i <= t; i++)
#define RP(i,s, t) for (i = t; i >= s; i--)
#define ll long long
#define ull unsigned long long
using namespace std;
inline int read()
{
    int a=0,b=1;
    char c=getchar();
    while(c<'0'||c>'9')
    {
        if(c=='-')
            b=-1;
        c=getchar();
    }
    while(c>='0'&&c<='9')
    {
        a=(a<<3)+(a<<1)+c-'0';
        c=getchar();
    }
    return a*b;
}
inline void write(int n)
{
    if(n<0)
    {
        putchar('-');
        n=-n;
    }
    if(n>=10)
        write(n/10);
    putchar(n%10+'0');
}
//状态: dp[i][j]表示由 j 个数构成 i 的最大的最小公倍数
//状态转移方程: dp[i][j] = max ( dp[i][j] , dp[i-k][j-1] * k / gcd(dp[i-k][j-1],k) )
//因为 (由 j 个数构成 i 的最大的最小公倍数，即dp[i][j]) 可以根据 (由j-1个数构成i-k的最大的最小公倍数,dp[i-k][j-1]) 和 (k)的最小公倍数得到（通过枚举k)。
//边界条件: dp[i][1] = i。因为只由一个数 i 构成
ll maxlcm[105],dp[105][105];
int prime[25] ={2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31,37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};

inline ll gcd(ll a,ll b){
    return b==0?a:gcd(b,a%b);
}
inline ll max(ll a,ll b){
    return a>b?a:b;
}
void init()
{
    int i,j,k;
    memset(dp,0,sizeof dp);
    rp(i,1,100) dp[i][1]=i;
    rp(i,2,100){
        rp(j,2,i){
            rp(k,1,i-1){
                if(i-k<j-1) break;
                dp[i][j]=max(dp[i][j],dp[i-k][j-1]*k/gcd(dp[i-k][j-1],k));
            }
        }
    }
    rp(i,1,100){
        maxlcm[i]=0;
        rp(j,1,100)
            maxlcm[i]=max(maxlcm[i],dp[i][j]);
    }
}
ll factor[105],prime_num;
void solve(ll num){//对maxlcm[n]进行质因子(幂)分解
    int i;
    prime_num=0;
    rp(i,0,24){
        if(num%prime[i]==0){
            ll temp=1;
            while(num%prime[i]==0){
                num/=prime[i];
                temp*=prime[i];
            }
            factor[prime_num++]=temp;
        }
    }
}
int main(){
	init();
    int T=read(),i,j;
    while(T--){
        int n=read();
        solve(maxlcm[n]);
        sort(factor,factor+prime_num);//从小到大排序
        int sum=0;
        rp(i,0,prime_num-1) sum+=factor[i];
        printf("%lld",maxlcm[n]);//输出最大的最小公倍数
        rp(i,1,n-sum) printf(" %d",i);//多余的转换成一阶循环输出（基于贪心的策略我们肯定直接输出前面的最优）
        int k=n-sum;//k用来记录上一个循环节的最大元素，
        //每一个循环节将第一个挪到后面去然后其余的向前推
        rp(i,0,prime_num-1){//枚举质因子幂
            rp(j,2,factor[i])//其他的往后输出，保证连续
                printf(" %d",j+k);
            printf(" %d",k+1);//输出第一个
            k+=factor[i];//累加
        }
        printf("\n");
    }
	return 0;
}