我想将十进制数转换为阶乘数字系统。
我想这样做是为了找到最多100个元素的nth Lexicographic排列，例如。 A [87] = {1,2,3 ...，87}
我得到索引'n'，我需要找到那个位置的词典排列。例如{1,2,3}的第二个排列是{1,3,2}
为此我试图使用阶乘数字系统。
以下链接提供有关转换方法的信息。
如十进制所述（463）给出341010！在阶乘。
463÷1 = 463，余数为0
463÷2 = 231，其余为1
231÷3 = 77，余数为0
77÷4 = 19，余数1
19÷5 = 3，其余为4
3÷6 = 0，余数3
只有十进制数落在允许范围内时才能应用此方法，如unsigned long long int。
如果数字不能适合整数范围，该怎么办？
我的测试用例涉及的数字太大，以至于需要以字符串格式存储。（例如查找123456789012345678901234555623344数组排列[100] = {1,2,3,4，...... 100}）
我正在尝试用c ++解决这个问题。
（在c ++中使用next_permutation（）来获得给定的索引是一种代价高昂的方法并且需要花费很多时间。）
答案 0 :(得分：0)
这是代码。你可以看到并问我任何困惑。
另外，我只提供了一个测试用例，并且我没有对代码进行详尽的测试。如果您发现任何错误，我将很乐意解决。
#include<bits/stdc++.h>
using namespace std;
#define MAX 1000000
#define MOD 1000000007
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define V vector
#define I int
#define D double
#define B bool
#define pii pair<int,int>
#define LL long long
#define in(x) scanf("%d",&x)
#define in2(x,y) scanf("%d%d",&x,&y)
#define lin(x) scanf("%lld",&x)
#define lin2(x,y) scanf("%lld%lld",&x,&y)
#define FOR(i,a,b) for(i=a;i<b;i++)
#define all(v) v.begin(),v.end()
string q; //this is the input
V<I> sol; //this is final solution vector. (will be printed in reverse)
void divide(I n){ //function to divide a string by `n`
string r = "";
I i,k=0;
FOR(i,0,q.length()){
k *= 10;
k += (q[i] - '0');
I g = k / n;
k = k % n;
if((r.length()==0 && g!=0) || (r.length()>0)){
r += (char)(g + '0');
}
}
q = r;
sol.PB(k);
}
I main(){
cin>>q;
I i;
FOR(i,1,101){ //assuming 100 is the limit
if(q.length()==0)
break;
divide(i);
}
//print the result
for(i=sol.size()-1;i>=0;i--)
//printf("%d ",sol[i]);
cout<<sol[i]<<" ";
printf("\n");
return 0;
}
答案 1 :(得分：0)
虽然标题声明您正在寻找将十进制数转换为整数的方法，但我将回答您尝试解决的实际问题：如何获得N数组的Kth排列元件。
简单地说，你需要逐个数字地预测给定数组的Kth排列。事情的理论方面非常简单。假设您拥有数组A中的元素，并且存储有关是否在第二个数组S中使用每个元素的信息。当您为每个数字选择适当的值时，将更新S.结果将存储在数组R中。
有N！给定数组A中元素的排列。对于具有N个数字的数组，如果A中的最小元素被选为结果中最左边的数字R [0]，则考虑有多少个排列。它（N-1）!,对吧？从＃1到＃（N-1）的排列！属于结果最左边的元素是A中最小元素的情况。排列＃（（N-1）！+ 1）到＃（2 *（N-1）！）具有第二个最小值A作为R [0]。所以排列＃（（i-1）*（N-1）！+ 1）到＃（i *（N-1）！）使用A中未使用且按字典顺序排列最小的数字作为R [0]。
在更广义的意义上，该值在Rth中使用，在第K个词典中，最小的排列是A [i]，使得A [i]是第i个词典上最小的元素，因此不使用远和（i *（N-1-d）！+ 1）＆lt; = k 和 k <=（（i + 1）*（N-1-） d）！）。
如果你遍历整个S，将需要 O（N）时间来找到合适的i值。我不确定你如何准确地实现它，但你也可以在S上进行二进制搜索，并在O（logN）时间内找到合适的i。
如果你有大K值，我认为你需要实现大整数乘法才能进行比较，但是如果我想到一个聪明的方法来解决这个问题，我会更新这部分答案此
一旦你选择了正确的i，你可以将A [i]指定为R [d]并继续寻找下一个数字。
以下是实现此解决方案的代码段。它很冗长，但大多数只是大整数实现。算法的要点实际上少于30行。我只是想提供一个有效的代码，以便您可以自己测试一下。
#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#define NLIMIT 100
#define ASIZELIMIT 101
#define BIGINTBUCKETSLIMIT 100
#define BUCKETCAPACITY 1000000000
#define DIGITSPERBUCKET 9
using namespace std;
/* sufficient big integer implementation */
class BigInt
{
/*
* Note that BIGINTBUCKETSLIMIT should be high enough so that
* the values given as input does not cause overflow
* or access violation from the last bucket in operations
* multiply and subtract.
*/
public:
long long buckets[BIGINTBUCKETSLIMIT];
BigInt() {
for(int i=0; i < BIGINTBUCKETSLIMIT; ++i) {
buckets[i] = 0LL;
}
}
BigInt(int initialValue) {
for(int i=0; i < BIGINTBUCKETSLIMIT; ++i)
{
buckets[i] = initialValue % BUCKETCAPACITY;
initialValue /= BUCKETCAPACITY;
}
}
void multiply(int val) {
for(int i= BIGINTBUCKETSLIMIT - 1; i >= 0; --i)
buckets[i] = buckets[i] * val;
for(int i=0; i < BIGINTBUCKETSLIMIT - 1; ++i) {
buckets[i+1] += buckets[i] / BUCKETCAPACITY;
buckets[i] = buckets[i] % BUCKETCAPACITY;
}
}
void subtract(BigInt B) {
for(int i= 0; i < BIGINTBUCKETSLIMIT; ++i) {
buckets[i] = buckets[i] - B.buckets[i];
if(buckets[i] < 0LL) {
buckets[i] += BUCKETCAPACITY;
buckets[i+1]--;
}
}
}
const BigInt & operator=(const BigInt &B) {
for(int i=0; i < BIGINTBUCKETSLIMIT; ++i)
buckets[i] = B.buckets[i];
return *this;
}
bool operator<(const BigInt &B) {
for(int i=BIGINTBUCKETSLIMIT-1; i >= 0; --i)
if(buckets[i] != B.buckets[i])
return buckets[i] < B.buckets[i];
return false;
}
void importFromStr(string &src)
{
long long buffer = 0, j = 0;
for(int i=src.size() - 1; i >= 0; i -= DIGITSPERBUCKET) {
buffer = 0;
for(int k=max(0, i - DIGITSPERBUCKET + 1); k <= i; ++k) {
buffer = buffer * 10 + (src[k] - '0');
}
buckets[j++] = buffer;
}
}
};
BigInt factorials[ASIZELIMIT];
void preprocessFactorials(int n)
{
factorials[0] = BigInt(1);
for(int i=1; i <= n; ++i) {
factorials[i] = factorials[i-1];
factorials[i].multiply(i);
}
}
void findKthPermutation(int N, int A[], BigInt K, int result[]) {
BigInt tmpBigInt;
bool S[ASIZELIMIT];
for(int i=0; i < N; ++i)
S[i] = true;
K.subtract(BigInt(1));
preprocessFactorials(N);
for(int d=0; d < N; ++d) {
for(int i=0, j=0; i < N; ++i) {
if(S[i]) {
tmpBigInt = factorials[N-1-d];
tmpBigInt.multiply(j+1);
if(K < tmpBigInt) {
result[d] = A[i];
S[i] = 0;
tmpBigInt = factorials[N-1-d];
tmpBigInt.multiply(j);
K.subtract(tmpBigInt);
break;
}
++j;
}
}
}
}
int main() {
string k;
BigInt K;
int N;
int A[ASIZELIMIT], R[ASIZELIMIT];
cin >> N >> k;
for(int i=0; i < N; ++i)
cin >> A[i];
K.importFromStr(k);
sort(A, A+N);
findKthPermutation(N, A, K, R);
cout << R[0];
for(int i=1; i < N; ++i)
cout << " " << R[i];
cout << endl;
return 0;
}
你可以很容易地观察函数findKthPermutation和我的BigInt类中的2个循环，无论K如何，实现都在O（N 3 ）中工作。虽然我不知道你的确切性能需求，如N <= 100，它可能足够有效。如果它没有你想要的那么高效，我的第一个建议是优化使用一些其他数据结构在S中存储信息，这些数据结构可以在O（logN）时间内为每个数字d寻找适当的i值。
最后，请注意，此解决方案假定A不包含重复元素，因为插入了可能的排列的词典编辑。