题解

144 条题解

  • 0
    @ 2006-10-25 18:06:48

    其实把1115改一改就可以AC了……我是这样做的~

  • 0
    @ 2006-10-19 19:23:22

    如:4 ,17

    (17-1)/a[3](=6)=2..4

    最高位为1+2=3

    4/a[2](=2)=2..0

    次高位为1+2=3(因3已用,故喉炎一个未用的数4)

    0/a[1](=1)=0..0

    第三位为1+0=1

    最后一位位未用的数2

  • 0
    @ 2006-10-18 08:39:32

    我晕

    我一个一个FOR的

    还有,INT64,IOSTREAM。。。

    IOSTREAM现在就有作用。。。

  • 0
    @ 2006-10-12 20:11:55

    一位一位地确定数字

    简单

    一次AC

  • 0
    @ 2006-09-24 19:23:10

    一个一个试的结果................

    编译通过...

    ├ 测试数据 01:答案正确... 0ms

    ├ 测试数据 02:答案正确... 0ms

    ├ 测试数据 03:答案正确... 0ms

    ├ 测试数据 04:答案正确... 197ms

    ├ 测试数据 05:运行超时...

    ├ 测试数据 06:运行超时...

    ├ 测试数据 07:运行超时...

    ├ 测试数据 08:运行超时...

    ---|---|---|---|---|---|---|---|-

    Unaccepted 有效得分:50 有效耗时:197ms

  • 0
    @ 2006-09-03 08:23:20

    用m div (n-1)! 的值来确定第一位,再用m mod (n-1)!的值依此类推就可得到排列!

  • 0
    @ 2006-08-21 12:54:49

    什么叫全排列啊???????????

    哪位大师请教以下~~~~~~~~~~~~

  • 0
    @ 2006-08-17 22:55:46

    编译通过...

    ├ 测试数据 01:答案正确... 0ms

    ├ 测试数据 02:答案正确... 0ms

    ├ 测试数据 03:答案正确... 0ms

    ├ 测试数据 04:答案正确... 0ms

    ├ 测试数据 05:答案正确... 0ms

    ├ 测试数据 06:答案正确... 0ms

    ├ 测试数据 07:答案正确... 0ms

    ├ 测试数据 08:答案正确... 0ms

    ---|---|---|---|---|---|---|---|-

    Accepted 有效得分:100 有效耗时:0ms

    我用的也是范围推导

    先确定第一个数的范围

    接着确定第2个。。。。

    这样的时间复杂度很低的

  • 0
    @ 2006-08-15 18:20:26

    回溯没有很强的优化是很慢的~~~

    我用的是范围推导,要快些

    编译通过...

    ├ 测试数据 01:答案正确... 0ms

    ├ 测试数据 02:答案正确... 0ms

    ├ 测试数据 03:答案正确... 0ms

    ├ 测试数据 04:答案正确... 0ms

    ├ 测试数据 05:答案正确... 0ms

    ├ 测试数据 06:答案正确... 0ms

    ├ 测试数据 07:答案正确... 0ms

    ├ 测试数据 08:答案正确... 0ms

    ---|---|---|---|---|---|---|---|-

    Accepted 有效得分:100 有效耗时:0ms

  • 0
    @ 2006-06-13 16:20:44

    随便推个每一位的方案数

    然后O(n)的枚举即可

  • 0
    @ 2006-06-04 21:41:28

    普通搜索是行不通的!!

  • 0
    @ 2006-04-06 16:42:05

    回溯算法

    用数组,每个元素用记录类型

    一个存数据 另一个判断

  • 0
    @ 2006-04-01 23:46:48

    好像和松鼠吃果子一样,建立一个用ASCII建立的字符串,然后算N的阶乘S(肯定要INT64),然后S=S除以N,最后输出字符串这个位置上(M除以S(如果不能整除那么就再+1))的数字,输出后删去这一位。M就等于M除以S的余数(如果整除就等于S),接下来DEC(N),重复以上过程N次即可(我不知道这算什么方法,请大虾赐教,快到还蛮快的,我是想到排列的树形图然后一点点推出来的)

  • -1
    @ 2018-08-03 17:30:20
    #include <bits/stdc++.h>
    using namespace std;
    #define FOR(i,n) for (int i=1;i<=n;i++)
    #define REP(i,a,b) for (int i=a;i<=b;i++)
    #define pb push_back
    #define mp make_pair
    #define ll long long
    const int N=100000+10;
    const int inf=0x3f3f3f3f;
    const ll mod=7777777;
    const double PI=3.1415926;
    const double eps=1e-8;
    
    int n;
    ll m;
    ll f[21];
    int a[21],b[21];
    bool used[21];
    int main() {
        //freopen("in.txt","r",stdin);
        //freopen("out.txt","w",stdout);
        f[0]=1;
        FOR(i,20) f[i]=f[i-1]*i;
        cin>>n>>m;
        FOR(i,n) b[i]=i;
        int now=1;
        while (now<=n) {
            //cout<<now<<" "<<m<<endl;
            if (m>=f[n-now]) {
                a[now]=b[(int)ceil((double)m/f[n-now])];
                m%=f[n-now];
                if (m==0) {
                    cout<<a[now]<<" ";
                    for (int i=n+1-now;i>=1;i--) {
                        if (b[i]!=a[now]) {
                            cout<<b[i]<<" ";
                        }
                    }
                    break;
                }
            } else a[now]=b[1];
            cout<<a[now]<<" ";
            used[a[now]]=1;
            FOR(i,n) if (b[i]!=inf&&used[b[i]]) b[i]=inf;
            sort(b+1,b+1+n);
            now++;
        }
        return 0;
    }
    
  • -1
    @ 2018-06-20 19:59:13

    https://vijos.org/records/5b2a410bd3d8a11ce730e66c

    #include<iostream>
    using namespace std;
    int n,m,a[25],b[25]={0};
    long long jc(int x)
    {
        long long sum=1;
        for (long long i=x;i>0;i--)
        sum*=i;
        return sum;
    }
    void pr()
    {
        for (int i=n;i>=1;i--)
        cout<<a[i]<<' ';
    }
    void list(int layer,int sum)
    {
        if (layer==1)
        {
            int o=1;
            while(1)
            {
                if(b[o]==0)
                {
                    a[1]=o;
                    break;
                }
                else
                    o++;
            }
            pr();
            return;
        }
        int now=0;
        for (int i=1;i<=n;i++)
        {
            if (b[i]==0)
            {
                now++;
                long long jcc=jc(layer-1);
                if (m<=now*jcc+sum)
                {
                    a[layer]=i;
                    b[i]=1;
                    list(layer-1,(now-1)*jcc+sum);
                    break;
                }
            }
        }
    }
    int main()
    {
        cin>>n>>m;
        if (m>jc(n))
            return 0; 
        list(n,0);
        return 0;
    } 
    
  • -1
    @ 2017-08-07 21:40:15

    C++ STL的next_permutation

    能过6个点,2个点超时

    在不知道楼下数学知识的情况下简便快速而又高效

    代码如下

    #include<iostream>
    #include<algorithm>
    #include<cstdio>
    using namespace std;
    int n,m;
    int a[24];
    int main(){
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++)
            a[i]=i;
        for(int i=1;i<m;i++){
            next_permutation(a+1,a+n+1);
        }
        for(int i=1;i<=n;i++)
            printf("%d ",a[i]);
    }
    
    • @ 2017-08-10 20:53:05

      请注意第二行...
      能过6个点,2个点超时

    • @ 2017-09-02 23:51:28

      @tongnian: 是的,忘了标注了

  • -1
    @ 2017-07-04 20:04:26

    dfs都不需要吧

    #include<stdio.h>
    #define L long long
    L js[21]; int n,m,vis[21]={0};
    int main(){
        for(int i=*js=1;i<=20;++i) js[i]=js[i-1]*i;
        scanf("%d%d",&n,&m); --m;
        for(int i=1;i<=n;++i){
            for(int j=1,t=0;j<=n;++j){
                t+=!vis[j];
                if(t*js[n-i]>m){
                    printf("%d ",j);
                    vis[j]=1; m-=(t-1)*js[n-i];
                    break;
                }
            }
        }
    }
    
  • -1
    @ 2016-12-06 19:17:58

    #include<iostream>
    #include<cstdio>
    #include<cstring>
    #define maxa 30
    using namespace std;
    long long n,m,flag =0,tot = 0,a[maxa],b[maxa];
    void dfs(int cur)
    {
    int i;
    if(cur==n)
    {
    tot++;
    if(tot==m)
    {
    flag = 1;
    for(i=0;i<n;++i)
    cout<<a[i]<<" ";
    }
    return ;
    }
    else for(i=1;i<=n;++i)
    if(b[i]==0)
    {
    a[cur] = i;
    b[i] = 1;
    dfs(cur+1);
    if(flag)
    return ;
    a[cur] = 0;
    b[i] = 0;
    }
    }
    int main()
    {
    memset(a,0,sizeof(a));
    memset(b,0,sizeof(b));
    cin>>n;
    cin>>m;
    dfs(0);
    return 0;
    }

  • -1
    @ 2016-10-03 21:27:27

    诡异的代码(432字符)
    测试数据 #0: Accepted, time = 0 ms, mem = 576 KiB, score = 10
    测试数据 #1: Accepted, time = 15 ms, mem = 576 KiB, score = 10
    测试数据 #2: Accepted, time = 0 ms, mem = 576 KiB, score = 10
    测试数据 #3: Accepted, time = 0 ms, mem = 580 KiB, score = 10
    测试数据 #4: Accepted, time = 0 ms, mem = 576 KiB, score = 10
    测试数据 #5: Accepted, time = 15 ms, mem = 576 KiB, score = 10
    测试数据 #6: Accepted, time = 0 ms, mem = 576 KiB, score = 10
    测试数据 #7: Accepted, time = 0 ms, mem = 576 KiB, score = 10
    Accepted, time = 30 ms, mem = 580 KiB, score = 80
    ~~~c++
    #include<iostream>
    using namespace std;
    long long n,m,a[25],k[25];
    void print(){
    for(int i=n;i;i--) cout<<a[i]<<' ';
    }
    void dfs(int w){
    if(w==0){
    print();return;
    }
    long long tmp,cnt=1;
    for(int i=2;i<w;i++) cnt*=i;
    a[w]++;
    while(m>cnt){
    m-=cnt;a[w]++;
    }
    tmp=a[w];
    a[w]=k[a[w]];
    for(int i=tmp;i<n;i++) k[i]=k[i+1];
    dfs(w-1);
    }
    int main(){
    for(int i=1;i<=25;i++) k[i]=i;
    cin>>n>>m;
    dfs(n);
    }
    ~~~

  • -1
    @ 2016-04-21 22:06:53

    测试数据 #0: Accepted, time = 0 ms, mem = 552 KiB, score = 10
    测试数据 #1: Accepted, time = 0 ms, mem = 552 KiB, score = 10
    测试数据 #2: Accepted, time = 0 ms, mem = 552 KiB, score = 10
    测试数据 #3: Accepted, time = 0 ms, mem = 552 KiB, score = 10
    测试数据 #4: Accepted, time = 0 ms, mem = 552 KiB, score = 10
    测试数据 #5: Accepted, time = 0 ms, mem = 552 KiB, score = 10
    测试数据 #6: Accepted, time = 0 ms, mem = 552 KiB, score = 10
    测试数据 #7: Accepted, time = 0 ms, mem = 552 KiB, score = 10
    测试数据 #8: Accepted, time = 0 ms, mem = 552 KiB, score = 10
    测试数据 #9: Accepted, time = 0 ms, mem = 552 KiB, score = 10
    Accepted, time = 0 ms, mem = 552 KiB, score = 100

信息

ID
1092
难度
5
分类
组合数学 点击显示
标签
(无)
递交数
4526
已通过
1400
通过率
31%
被复制
11
上传者