组合基础小记

一直不大喜欢写题解 尤其做的很纠结的题目 终于纠结完了 就想代码一贴完事。缺点一：理解不透彻；二：很容易忘；三：不利于以后回顾复习；四：写代码容易乱；

以这个专题为开始吧 把一些题目总结一下 解释一下 同一类型的放在一块 。

hdu1465 不容易系列之一 （错排公式）

虽说大家知道 还是把这个小小说一下

来自百度百科

当n个编号元素放在n个编号位置，元素编号与位置编号各不对应的方法数用D(n)表示，那么D(n-1)就表示n-1个编号元素放在n-1个编号位置，各不对应的方法数，其它类推.

第一步，把第n个元素放在一个位置，比如位置k，一共有n-1种方法；

第二步，放编号为k的元素，这时有两种情况：⑴把它放到位置n，那么，对于剩下的n-1个元素，由于第k个元素放到了位置n，剩下n-2个元素就有D(n-2)种方法；⑵第k个元素不把它放到位置n，这时，对于这n-1个元素，有D(n-1)种方法；

综上得到

D(n) = (n-1) [D(n-2) + D(n-1)]

#include <iostream>
#include<cstdio>
#include<stdlib.h>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<set>
using namespace std;
#define LL long long
LL f[22];
int main()
{
    int i,n;
    f[1] = 0;
    f[2] = 1;
    while(cin>>n)
    {
        for(i = 3; i <= n ; i++)
        f[i] = (i-1)*(f[i-1]+f[i-2]);
        cout<<f[n]<<endl;
    }
    return 0;
}

poj1850 Code

以前做过 没印象了。。

仔细想一下 也是很简单的 一个字母的所有排列就是C（n,1),二个字母C（n,2),三个字母C(n,3)........依次

具体的就类似于逐位了 注意下细节就OK了

#include <iostream>
#include<cstdio>
#include<stdlib.h>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<set>
using namespace std;
#define LL long long
char s[12];
LL c[30][15];
void init()
{
    int i,j;
    for(i = 0 ;i <= 26 ;i++)
    c[i][0] = 1;
    for(i = 1 ; i <= 26 ;i++)
        for(j = 1 ; j <= 10 ; j++)
        c[i][j] = c[i-1][j-1]+c[i-1][j];
}
int main()
{
    int i,j,k;
    init();
    while(cin>>s)
    {
        k = strlen(s);
        if(k>1)
        {
             for(i = 0 ; i < k-1 ; i++)
            if(s[i+1]<s[i]) break;
            if(i!=k-1) {puts("0");continue;}
        }
        LL ans=0;
        for(i = 1 ; i < k ;i++)
        ans+=c[26][i];
        int t;
        for(i = 0; i < k ;i++)
        {
            if(i!=0)
            t = 'z'-s[i-1]-1;
            else
            t = 25;
            //cout<<'z'-s[i]+1<<endl;
            for(j = max(('z'-s[i]+1),k-i-1) ; j <= t ; j++)
            {
                //cout<<j<<endl;
                ans+=c[j][k-i-1];
            }
        }
        ans++;
        cout<<ans<<endl;
    }
    return 0;
}

poj2773 Happy 2006  二分+容斥原理

容斥原理可以明显的看的出 也算是模板题了

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stdlib.h>
#include<vector>
#include<stack>
#include<queue>
#include<cmath>
using namespace std;
#define N 10000000000
#define LL long long
int p[32],g;
LL sum=0;
int gcd(int a,int b)
{
    return b==0?a:gcd(b,a%b);
}
void dfs(int num,LL y,int i,LL n)
{
    y = p[i]*y;
    if(num%2==0) sum-=n/y;
    else sum+=n/y;
    for(int j = i+1 ; j <= g ; j++)
    dfs(num+1,y,j,n);
}
int main()
{
    int m,k,i;
    while(cin>>m>>k)
    {
        g = 0;
        for(i = 2; i <= m ;i++)
        {
            if(m%i==0) p[++g] = i;
            while(m%i==0)
            {
                m/=i;
            }
        }
        if(m!=1) p[++g] = m;
        LL low = 1,high = N,mid;
        LL ans;
        while(low<=high)
        {
            mid = (low+high)/2;
            sum=0;
            for(i = 1; i <= g; i++)
            {
                dfs(1,1,i,mid);
            }
            /*if(mid-sum==k)
            {
                while(gcd(mid,k)!=1)mid--;
                break;
            }*/
            if(mid-sum<k) low = mid+1;
            else {high = mid-1;}
        }
        cout<<low<<endl;
    }
    return 0;
}

POJ 1091 跳蚤  容斥

这跳骚很牛X 。。特别能跳  

这个可以想到 可以跳出相差为一的 就是gcd(x1,x2,,....xn) = 1，具体我也不知道怎么证  我是以欧几里得猜的 ax+by = gcd(x,y) 有解

这个题求补集 把每一次的减去

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stdlib.h>
#include<vector>
#include<cmath>
#include<queue>
#include<set>
using namespace std;
#define N 100000
#define LL __int64
#define INF 0xfffffff
const double eps = 1e-8;
const double pi = acos(-1.0);
const double inf = ~0u>>2;
int p[32];
double ppow(int x,int n)
{
    int i;
    double s = 1;
    for(i = 1; i <= n ;i++)
    s*=x;
    return s;
}
int main()
{
    int i,j,n,m;
    scanf("%d%d",&n,&m);
    int g = 0;
    int q = m;
    for(i = 2 ; i*i <= m ;i++)
    {
        if(m%i==0) p[++g] = i;
        while(m%i==0)
        m/=i;
        if(i>m) break;
    }
    if(m!=1) p[++g] = m;
    double s = ppow(q*1.0,n);
    for(i = 1 ; i < (1<<g) ; i++)
    {
        int o = 0,y=1;
        for(j = 0 ; j < g ; j++)
        {
            if(i&(1<<j))
            {
                o++;
                y*=p[j+1];
            }
        }
        LL x = q/y;
        if(o%2) s-=ppow(x,n);
        else s+=ppow(x,n);
    }
    printf("%I64d\n",(LL)s);
    return 0;
}

HDU 1695 GCD   容斥

这个其实把最大公约数除去之后 求一下互质的个数 可能数据有点水吧 直接枚举每一个的与其互质的个数 然后加起来 

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stdlib.h>
#include<cmath>
#include<vector>
using namespace std;
#define LL __int64
#define N 100010
LL o[N];
int p[22];
LL init(int s1,int s2)
{
    int i,j,e;
    LL cnt = 0;
    for(i = s1 ; i >= 2 ; i--)
    {
        int g = 0,x=i;
        for(j = 2 ; j*j <= x ; j++)
        {
            if(x%j==0){p[++g] = j;}
            while(x%j==0) x/=j;
        }
        if(x!=1) p[++g] = x;
        int ans = i+s2-s1;
        for(j = 1 ; j < (1<<g) ; j++)
        {
            int s = 0,y=1;
            for(e = 0 ; e < g ; e++)
            {
                if(j&(1<<e))
                {
                    s++;
                    y*=p[e+1];
                }
            }
            if(s%2)
            {
                ans-=i/y; ans-=(s2/y-s1/y);
            }
            else {ans+=i/y;ans+=(s2/y-s1/y);
            }
        }
        cnt += ans;
    }
    return cnt+s2-s1+1;
}
int main()
{
    int k,a,b,c,d;
    int t,kk=0;
    cin>>t;
    while(t--)
    {
        scanf("%d%d%d%d%d",&a,&b,&c,&d,&k);
        if(b>d) swap(b,d);
        printf("Case %d: ",++kk);
        if(k==0||b<k)
        {
            cout<<"0\n";
            continue;
        }
        cout<<init(b/k,d/k)<<endl;
    }
    return 0;
}

HDU 2079  选课时间  普通型母函数

直接套模板

#include <iostream>
#include<cstdio>
#include<cstring>
#include<cstdio>
#include<stdlib.h>
#include<cmath>
#include<vector>
using namespace std;
int k[10],o[10],num[10];
int c1[55],c2[55];
bool f[10];
int main()
{
    int i,j,a,b,n,k,t,e;
    cin>>t;
    while(t--)
    {
        memset(o,0,sizeof(o));
        memset(f,0,sizeof(f));
        memset(c1,0,sizeof(c1));
        memset(c2,0,sizeof(c2));
        cin>>n>>k;
        int g = 0;
        for(i = 1; i <= k ;i++)
        {
            cin>>a>>b;
            o[a]+=b;
            if(!f[b])
            {
                num[++g] = a;
            }
        }
        for(i = 0 ; i <= num[1]*o[num[1]] &&i<=n; i += num[1])
        c1[i] = 1;
        for(i = 2 ; i <= g ;i++)
        {
            for(j = 0 ; j <= n ; j++)
            for(e = 0 ; e+j<=n&&e <= num[i]*o[num[i]] ; e+=num[i])
            {
                c2[j+e]+=c1[j];
            }
            for(j = 0 ; j <= n ;j++)
            {
                c1[j] = c2[j];
                c2[j] = 0;
            }
        }
        cout<<c1[n]<<endl;
    }
    return 0;
}

HDU 1521 排列组合  指数型母函数 （见上个）

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stdlib.h>
#include<vector>
#include<cmath>
#include<queue>
#include<set>
using namespace std;
#define LL long long
#define INF 0xfffffff
const double eps = 1e-8;
const double pi = acos(-1.0);
const double inf = ~0u>>2;
double c1[22],c2[22];
int b[12];
int cn(int x)
{
    int i,s=1;
    for(i = 1; i <= x ; i++)
    s*=i;
    return s;
}
int main()
{
    int i,j,n,m;
    while(cin>>n>>m)
    {
        memset(c1,0,sizeof(c1));
        memset(c2,0,sizeof(c2));
        for(i = 1; i <= n; i++)
        {
            cin>>b[i];
        }
        for(i = 0 ;i<=b[1] ;i++)
        c1[i] = 1.0/cn(i);
        for(i = 2; i <= n ;i++)
        {
            for(j = 0 ;j <= m ;j++)
            {
                for(int g = 0 ; g <= b[i] ; g++)
                c2[j+g] += 1.0*c1[j]/cn(g);
            }
            for(j = 0 ; j <= m ;j++)
            {
                c1[j] = c2[j];
                c2[j] = 0;
            }
        }
        printf("%0.lf\n",c1[m]*cn(m));
    }
    return 0;
}

 

 hdu 1812 polya 数太大直接用JAVA了 

旋转 0   n*n

90    偶数 n*n/4 奇数 (n*n-1)/4

180  偶数 n*n/2 奇数 （n*n-1）/2 

270  偶数 n*n/4 奇数 (n*n-1)/4

对角折  (n*n-n)/2+n 两次 

中线折 偶数 (n*n)/2  奇数(n*n-n)/2+n 两次

import java.text.*;
import java.io.*;
import java.util.*;
import java.math.*;
import java.applet.*;
public class Main 
{
    public static void main(String args[])
    {
        BigInteger cnt;
        Scanner cin = new Scanner(System.in);
        int i,j,n,m;
        while(cin.hasNextInt())
        {
            n = cin.nextInt();
            m = cin.nextInt();
            cnt = BigInteger.valueOf(0);
            BigInteger bn = BigInteger.valueOf(m);
            cnt = cnt.add(bn.pow(n*n));
            if(n%2==0)
            {
                cnt = cnt.add(bn.pow(n*n/4).multiply(BigInteger.valueOf(2)));
                cnt = cnt.add(bn.pow(n*n/2));
                cnt = cnt.add(bn.pow((n*n-n)/2+n).multiply(BigInteger.valueOf(2)));
                cnt = cnt.add(bn.pow(n*n/2).multiply(BigInteger.valueOf(2)));
            }
            else
            {
                cnt = cnt.add(bn.pow((n*n-1)/4+1).multiply(BigInteger.valueOf(2)));
                cnt = cnt.add(bn.pow((n*n-1)/2+1));
                cnt = cnt.add(bn.pow((n*n-n)/2+n).multiply(BigInteger.valueOf(4)));
            }
            System.out.println(cnt.divide(BigInteger.valueOf(8)));
        }
    }
}

 POJ 1286 Necklace of Beads   经典的polay计数 

其实对于burnside不是特别的理解 只是大体的记得了公式 大体了解 知道哪一类题是用它来解的。 下面可能会把点说成珠子。。。

文库里讲的都很清楚 可以初步了解下 这个题大体说一下  抛开重复不说 对于每个点可以染k种颜色 那么可以染的可能为n^k 因为旋转或者翻转使得一些可能变成了相同的 这时候就要删除相同的  引入置换的概念 举个例子就是在某种置换下 a->b c->d 也就是说本来该是 4^k  现在对折置换之后 a与b c与d 其实是一样的 那么很明显就变成了2^k。

 这个题 包括两种置换 一是 旋转置换 二是 翻转置换 

对于旋转： 套定理 k^gcd(i,n) (0<i<=n)

对于翻转： 因为要对折  就要考虑奇数 和偶数  奇数： 沿穿过每个珠子的线对折 n个置换 (（n-1）/2+1)^k

偶数 沿穿过珠子的线 n/2个置换 ((n-2)/2+2)^k 不穿过珠子的线 n/2个置换 （n/2）^k

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stdlib.h>
#include<vector>
#include<cmath>
#include<queue>
#include<set>
using namespace std;
#define N 100000
#define LL long long
#define INF 0xfffffff
const double eps = 1e-8;
const double pi = acos(-1.0);
const double inf = ~0u>>2;
int gcd(int a,int b)
{
    return b==0?a:gcd(b,a%b);
}
int main()
{
    int i,n;
    while(cin>>n)
    {
        if(n==-1) break;
        LL s = 0;
        if(n==0)
        {
            cout<<"0\n";
            continue;
        }
        for(i = 1 ; i <= n ;i++)
        {
            s+=(LL)pow(3.0,gcd(i,n));
        }
        if(n%2==0)
        cout<<(s+n/2*(LL)pow(3.0,(n-2)/2+2)+n/2*(LL)pow(3.0,n/2))/2/n<<endl;
        else
        cout<<(s+n*(LL)pow(3.0,(n-1)/2+1))/2/n<<endl;
    }
    return 0;
}

POJ 2409 Let it Bead 同上 其实上题的题解该是本题的 上一题的K就是为3

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stdlib.h>
#include<vector>
#include<cmath>
#include<queue>
#include<set>
using namespace std;
#define N 100000
#define LL long long
#define INF 0xfffffff
const double eps = 1e-8;
const double pi = acos(-1.0);
const double inf = ~0u>>2;
int gcd(int a,int b)
{
    return b==0?a:gcd(b,a%b);
}
int main()
{
    int i,n,k;
    while(cin>>k>>n)
    {
        if(!n&&!k) break;
        if(n==0)
        {
            cout<<"0\n";
            continue;
        }
        LL s = 0;
        for(i = 1 ; i <= n ;i++)
        {
            s+=(LL)pow(k*1.0,gcd(i,n));
        }
        if(n%2==0)
        cout<<(s+n/2*(LL)pow(k*1.0,(n-2)/2+2)+n/2*(LL)pow(k*1.0,n/2))/2/n<<endl;
        else
        cout<<(s+n*(LL)pow(k*1.0,(n-1)/2+1))/2/n<<endl;
    }
    return 0;
}

POJ 1026 Cipher 这个属于置换群的题 找出循环节 总循环节就等于lcm(x1,x2,x3) 所有的循环节的最小公倍数

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stdlib.h>
#include<cmath>
using namespace std;
#define LL long long
LL gcd(LL a,LL b)
{
    return b==0?a:gcd(b,a%b);
}
char s[210],ss[210];
int a[210],q[210][210],o[210];
int b[210];
bool vis[210];
int main()
{
    int i,j,n,m;
    while(cin>>n)
    {
        if(!n) break;
        memset(vis,0,sizeof(vis));
        for(i = 1; i <= n ;i++)
        scanf("%d",&a[i]);
        int kk = 0;
        for(i = 1; i <= n; i++)
        {
            if(!vis[i])
            {
                kk++;
                int g = 0;
                q[kk][++g] = i;
                vis[i]=1;
                int x = a[i];
                while(!vis[x])
                {
                    vis[x] = 1;
                    q[kk][++g] = x;
                    x = a[x];
                }
                o[kk] = g;
            }
        }
        LL lcm = 1;
        for(i = 1; i <= kk ; i++)
        {
            lcm = lcm/gcd(lcm,o[i])*o[i];
        }
        while(scanf("%d%*c",&m)!=EOF)
        {
            if(!m) break;
            gets(s);
            int k = strlen(s);
            for(i = k ; i < n ;i++)
            s[i] = ' ';
            s[n] = '\0';
            m = m%lcm;
            for(i = 1; i <= kk ;i++)
            {
                int ko = m%o[i];
                for(j = 1; j <= o[i] ; j++)
                {
                    if(j+ko<=o[i])
                    b[q[i][j]] = q[i][j+ko];
                    else
                    {
                        b[q[i][j]] = q[i][j+ko-o[i]];
                    }
                }
            }
            for(i = 0 ;i < n ; i++)
            {
                ss[b[i+1]] = s[i];
            }
            for(i = 1 ;i <= n ;i++)
            printf("%c",ss[i]);
            puts("");
        }
        puts("");
    }
    return 0;
}

POJ 1721 CARDS 这个题说是置换幂的应用  也是先找出循环节 然后减去m次（这里根据长度 变换一下）  就是逆运算 变回去 

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stdlib.h>
#include<cmath>
#include<vector>
using namespace std;
#define N 1010
int a[N],b[N][N];
int main()
{
    int i,j,n,m;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(i = 1; i <= n ;i++)
        {
            scanf("%d",&a[i]);
            b[1][i] = a[i];
        }
        for(i = 2; ; i++)
        {
            for(j = 1; j <= n ;j++)
            {
                b[i][j] = b[i-1][b[i-1][j]];
            }
            /*for(j = 1; j <= n ;j++)
            cout<<b[i][j]<<" ";
            puts("");*/
            for(j = 1; j <= n ;j++)
            {
                if(b[i][j]!=b[1][j]) break;
            }

            if(j==n+1) break;
        }
        int k = i-1;
        m = m%k;
        //cout<<m<<endl;
        for(i = 1; i <= n; i++)
        printf("%d\n",b[k+1-m][i]);
    }
    return 0;
}

POJ 3128 Leonardo's Notebook  算是置换开方的应用 有结论是 偶数度的循环节是可以由两个相同偶数度的结合而来 奇数则有奇数而来 具体看一下置换群快速幂运算的研究吧

这样就可以在给出的串中找每个循环（也称置换也称轮换）的循环节  看偶数度的是否是成对出现 是 则一定可以有某个置换平方而来 不然则不可以

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stdlib.h>
#include<vector>
#include<cmath>
#include<queue>
#include<set>
using namespace std;
#define N 100000
#define LL long long
#define INF 0xfffffff
const double eps = 1e-8;
const double pi = acos(-1.0);
const double inf = ~0u>>2;
char s[30],ss[30];
int p[500];
bool vis[500];
int main()
{
    int i,j,n;
    cin>>n;
    while(n--)
    {
        memset(vis,0,sizeof(vis));
        memset(p,0,sizeof(p));
        cin>>s;
        for(i = 0  ;i < strlen(s) ; i++)
        {
            if(!vis[i])
            {
                vis[i] = 1;
                j = s[i]-'A';
                int o = 1;
                while(!vis[j])
                {
                    vis[j] = 1;
                    j = s[j]-'A';
                    o++;
                }
                p[o]++;
            }
        }
        int ans=0;
        for(i = 2; i <= 26 ; i+=2)
        if(p[i]%2) break;
        if(i<=26) puts("No");
        else puts("Yes");
    }
    return 0;
}

POJ 3590  The shuffle Problem  也是属于置换 不过涉及到最小公倍数最小 即总循环节最小 要把整数拆分为最小公倍数最大 我用dp+置换解的

 先dp出最小公倍数最大的解 然后依次枚举字典序最小 也就是前几块分割长度越小越好 

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stdlib.h>
#include<vector>
#include<cmath>
#include<queue>
#include<set>
using namespace std;
#define N 100000
#define LL long long
#define INF 0xfffffff
const double eps = 1e-8;
const double pi = acos(-1.0);
const double inf = ~0u>>2;
int p[110],g,b[110];
LL dp[110][110];
int o[110][110],sum[110];
int w[110],pp[110],q[110];
LL gcd(LL a,LL b)
{
    return b==0?a:gcd(b,a%b);
}
void init(int n)
{
    int i,j;
    sum[0] = 0;
    for(i = 1; i <= n ;i++)
    {
        sum[i] = sum[i-1]+1;
        dp[1][i] = sum[i];
    }
    for(i = 2; i <= n ; i++)
        for(j = n; j >= 1 ; j--)
        for(g = 1; g < j; g++)
        {
            LL k = dp[i-1][g]/gcd(dp[i-1][g],sum[j]-sum[g])*(sum[j]-sum[g]);
            if(dp[i][j]<=k)
            {
                dp[i][j] =k;
                o[i][j] = g;
            }
        }
}
int main()
{
    int i,j,n,t;
    cin>>t;
    while(t--)
    {
        cin>>n;
        memset(dp,0,sizeof(dp));
        init(n);
        LL ans = 1;
        LL maxz = 0;
        int x;
        pp[0] = n;
        for(i = 1; i <= n  ;i++)
        {
            if(maxz<=dp[i][n])
            {
                x = i;
                maxz = dp[i][n];
            }
            pp[i] = n;
        }
        int gg;
        for(i = 2; i <= n;i++)
        {
            if(dp[i][n]==maxz)
            {
                int g = 0;
                x = i;
                int y = o[x][n];
                p[++g] = y;x--;
                while(x!=1)
                {
                    y = o[x][y];
                    p[++g] = y;
                    x--;
                }
                int l=0;
                p[g+1] = 0;
                p[0] = n;
                for(j = 1 ; j <=g+1 ; j++)
                {
                    q[l++] = p[j-1]-p[j];
                }

                sort(q,q+l);
                int f = 1;
                for(j = 0 ;j < l ;j++)
                {
                    if(q[j]>pp[j]) {
                        f = 0;
                        break;
                    }
                    else if(q[j]<pp[j]) break;
                }
                if(f)
                {
                    gg = l;
                    for(j = 0; j < l ;j++)
                        pp[j] = q[j];
                }
            }

        }
        cout<<maxz<<" ";
        int tt=0;
        for(i = 0; i < gg  ; i++)
        {
            for(j = tt+1 ; j <= tt+pp[i]; j++)
            {
                if(j+1<=pp[i]+tt)
                b[j] = j+1;
                else
                b[j] = tt+1;
            }
            tt+=pp[i];
        }
        if(n==1) b[1] = 1;
        for(i = 1; i < n; i++)
        cout<<b[i]<<" ";
        cout<<b[n]<<endl;
    }
    return 0;
}