基础专题

1.hdu 1028 Ignatius and the Princess III 整数划分

#include<stdio.h>
__int64 dp[121][121];
int main()
{
    __int64 i,j,k,n,m;
    for(i=0;i<=120;i++)
        for(j=0;j<=120;j++)
            dp[i][j]=0;
    for(i=1;i<=120;i++)
    {
        dp[i][1]=1;
        dp[1][i]=1;
    }
    for(i=1;i<=120;i++)
        for(j=1;j<=120;j++)
        {
            if(i<j)
                dp[i][j]=dp[i][i];
            else if(i>j)
                dp[i][j]=dp[i-j][j]+dp[i][j-1];
            else if(i==j)
                dp[i][j]=1+dp[i][j-1];
        }
    while(scanf("%I64d",&n)>0)
    {
        printf("%I64d\n",dp[n][n]);
    }
    return 0;
}

2.hdu 1133 Buy the Ticket

这道题，以前没有用java的时候，还没有ac。

题意：有n个人手上有50元，m个人手上有100元。售票员手上没有零钱，所以必须要拥有50元的人先买。在任何时候，都要满足

        50的人数>=100的人数才能满足题意要求。而且，每个人是不一样的，所以针对拥有50元 或者 100 的人又是有序的。

思路：dp[ i ] [ j ] 代表前 i  个人中，有 j 个50元的人已经买票了。

if( j > i - j ) dp[ i ] [ j ] = dp[ i -1] [j -1 ] + dp[i - 1] [ j ]; 讨论第i 个人是50元 还是 100元。

else dp[ i ] [ j ] = dp[ i-1 ] [ j-1 ];//此时只能由50元的人买票了.

由于有序，所以dp[n+m][n]*c[n]*c[m]; c[ ]代表阶乘.

//输入上要注意一下，m未必<=n，所以这样的情况，直接为0.

//package mywork;

import java.util.*;
import java.math.BigInteger;
import java.io.*;

public class Main {

    static BigInteger c[] = new BigInteger[101];
    static BigInteger dp[][]= new BigInteger[202][202];
                                          
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        fun();
        int t=1;
        Scanner cin  = new Scanner(System.in);
        while(cin.hasNext()){
            int n = cin.nextInt();
            int m = cin.nextInt();
            if(n==0&&m==0)break;
            if(m>n){
                System.out.println("Test #"+t+":");
                t++;
                System.out.println("0");
                continue;
            }
            BigInteger hxl = dp[n+m][n].multiply(c[n]).multiply(c[m]);
            System.out.println("Test #"+t+":");
            System.out.println(hxl);
            t++;
        }
    }
    static void fun(){
        c[0] = BigInteger.ONE;
        for(int i=1;i<=100;i++)
            c[i] = c[i-1].multiply(BigInteger.valueOf(i));
        
        for(int i=0;i<=200;i++){
            for(int j=0;j<=200;j++)
            dp[i][j] = BigInteger.ZERO;
        }
        dp[1][1]=BigInteger.ONE;
        for(int i=2;i<=200;i++){
            for(int j=1;j<=i;j++){
                if(j>i-j)
                    dp[i][j] = dp[i-1][j].add(dp[i-1][j-1]);
                else dp[i][j] = dp[i-1][j];
            }
        }
    }
}

3.poj 3088 Push Botton Lock

// I want to say fuck!
题意： 给n个数字(1<=n<=11) ,从中选出 k 个元素，对于每一种情况，k个元素，求能分出几种集合。
       一个元素只能在一个集合，一个集合中的元素是无序的，集合与集合之间是有序的。
       这个是一种特殊的数转化过来的。
思路： n中选k个就有Cn1  Cn2 Cn3 .... Cnn这些情况。
       对于每一种情况，求dp[i][j]代表，有i个元素，j个集合，则满足递推式
       dp[i][j]=j*dp[i-1][j]+dp[i-1][j-1];
       当然，集合与集合直接是无序的，所以最后的时候，要乘 阶乘j.(集合的个数）
#include<stdio.h>
typedef __int64 LL;

LL dp[101][101];
LL ans[13][13];
LL nima[12]={1};

void Init()
{
    int i,j;
    for(i=1;i<=11;i++) nima[i]=nima[i-1]*i;
    for(i=0;i<=11;i++) ans[i][0]=1;
    for(i=1;i<=11;i++)
    {
        for(j=1;j<=11;j++)
        {
            if(j==1) ans[i][1]=i;
            else if(j==i) ans[i][i]=1;
            else ans[i][j]=ans[i-1][j-1]+ans[i-1][j];
        }
    }
    dp[1][1]=1;
    for(i=2;i<=100;i++)
        for(j=1;j<=i;j++)
        {
            dp[i][j]=j*dp[i-1][j]+dp[i-1][j-1];
        }
}
int main()
{
    int T,i,j,n,t;
    LL sum,hxl;
    Init();
    scanf("%d",&T);
    for(t=1;t<=T;t++)
    {
        scanf("%d",&n);
        sum=0;
        for(i=1;i<=n;i++)
        {
            hxl=0;
            for(j=1;j<=i;j++)
                hxl=hxl+dp[i][j]*nima[j];
            sum=sum+hxl*ans[n][i];
        }
        printf("%d %d %I64d\n",t,n,sum);
    }
    return 0;
}

4.poj 1496 Word Index

/*写得很糟
  用了一个所谓的字符串哈希，发现以前神马都不管用。
  ar 和 bc 都是同样的hash值。(⊙o⊙)…，不想改太多，就加了了
  字符串判断了。
  其实，由于长度<=5 而且 字母不会出现相同，用二进制哈希就很好了。
  那么其他方法？？
*/
#include<iostream>
#include<stdio.h>
#include<cstring>
#include<string>
#include<cstdlib>
using namespace std;

struct node
{
    int x;
    int val;
    char str[7];
    struct node *next;
}f[100007];
void insert(int x,int num,char c[])
{
    int k=x%100007;
    node *p;
    p=f[k].next;
    while(p!=NULL && (p->x!=x ||strcmp(p->str,c)!=0))
    {
        p=p->next;
    }
    if(p==NULL)
    {
        p=(struct node*)malloc(sizeof(struct node));
        p->next=f[k].next;
        f[k].next=p;
        p->x=x;
        strcpy(p->str,c);
        p->val=num;
    }
}
int found(int x,char c[])
{
    int k=x%100007;
    node *p;
    p=f[k].next;
    while(p!=NULL && (p->x!=x || strcmp(p->str,c)!=0) )
    {
        p=p->next;
    }
    if(p!=NULL) return p->val;
    return 0;
}
unsigned int ELFHash(char *str)
{
    unsigned int hash = 0;
    unsigned int x = 0;
    while (*str)
    {
        hash = (hash << 4) + (*str++);
        if ((x = hash & 0xF0000000L) != 0)
        {
            hash ^= (x >> 24);
            hash &= ~x;
        }
    }
    return (hash & 0x7FFFFFFF);
}
void Init()
{
    int i,j,s,t,k,tom=0,hxl;
    for(i=0;i<100007;i++)
    {
        f[i].next=NULL;
        f[i].val=f[i].x=0;
        f[i].str[0]='\0';
    }
    char A='a'-1;
    char b[10];
    for(i=1;i<=26;i++)
    {
        b[0]=i+A;
        b[1]='\0';
        hxl=ELFHash(b);
        ++tom;
        insert(hxl,tom,b);
    }//one
    for(i=1;i<=26;i++)
    {
        for(j=i+1;j<=26;j++)
        {
            b[0]=A+i;
            b[1]=A+j;
            b[2]='\0';
            hxl=ELFHash(b);
            ++tom;
            insert(hxl,tom,b);
        }
    }//two
    for(i=1;i<=26;i++)
        for(j=i+1;j<=26;j++)
            for(k=j+1;k<=26;k++)
            {
                b[0]=A+i;
                b[1]=A+j;
                b[2]=A+k;
                b[3]='\0';
                hxl=ELFHash(b);
                ++tom;
                insert(hxl,tom,b);
            }//three
    for(i=1;i<=26;i++)
    {
        for(j=i+1;j<=26;j++)
        {
            for(k=j+1;k<=26;k++)
            {
                for(s=k+1;s<=26;s++)
                {
                    b[0]=i+A;
                    b[1]=j+A;
                    b[2]=k+A;
                    b[3]=s+A;
                    b[4]='\0';
                    hxl=ELFHash(b);
                    ++tom;
                    insert(hxl,tom,b);
                }
            }
        }
    }//four
    for(i=1;i<=26;i++)
    {
        for(j=i+1;j<=26;j++)
        {
            for(k=j+1;k<=26;k++)
            {
                for(s=k+1;s<=26;s++)
                {
                    for(t=s+1;t<=26;t++)
                    {
                        b[0]=i+A;
                        b[1]=j+A;
                        b[2]=k+A;
                        b[3]=s+A;
                        b[4]=t+A;
                        b[5]='\0';
                        hxl=ELFHash(b);
                        ++tom;
                        insert(hxl,tom,b);
                    }
                }
            }
        }
    }//five

}
int main()
{
    Init();
    bool flag;
    char a[10];
    int i,j,k;
    while(scanf("%s",a)>0){
        k=strlen(a);
        flag=false;
        for(i=0;i<k;i++)
        {
            for(j=i+1;j<k;j++)
                if(a[i]>=a[j])flag=true;
        }
        if(flag==true){
            printf("0\n");
            continue;
        }
        k=ELFHash(a);
        k=found(k,a);
        printf("%d\n",k);
    }
    return 0;
}

5.poj 1942 Paths on a Grid Cn+m n

#include<stdio.h>
typedef __int64 LL;

int main()
{
    LL n,m,k,sum,i,j;
    while(scanf("%I64d%I64d",&n,&m)>0)
    {
        if(n==0&&m==0)break;
        k=n+m;
        if(n>m) n=m;
        sum=1;
        for(i=1,j=k;i<=n;i++,j--)
            sum=sum*j/i;
        printf("%I64d\n",sum);

    }
    return 0;
}

6.fzu 2020 组合

#include<iostream>
#include<stdio.h>
#include<cstring>
#include<cstdlib>
using namespace std;
typedef long long LL;

LL pow_mod(LL a,LL b,LL p)
{
    LL ans=1;
    while(b)
    {
        if(b&1) ans=(ans*a)%p;
        b=b>>1;
        a=(a*a)%p;
    }
    return ans;
}
LL C(LL a,LL b,LL p){
    if(a<b) return 0;
    if(b>a-b) b=a-b;
    LL i,sum1=1,sum2=1;
    for(i=0;i<b;i++){
        sum1=(sum1*(a-i))%p;
        sum2=(sum2*(b-i))%p;
    }
    return (sum1*pow_mod(sum2,p-2,p))%p;
}
LL Lucas(LL n,LL m,LL p)
{
    LL ans=1;
    while(n&&m&&ans)
    {
        ans=(ans*C(n%p,m%p,p))%p;
        n=n/p;
        m=m/p;
    }
    return ans%p;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--){
        LL n,m,p;
        scanf("%lld%lld%lld",&n,&m,&p);
        if(p==1){
            printf("0\n");
            continue;
        }
        printf("%lld\n",Lucas(n,m,p));
    }
    return 0;
}

/**
 题意：C(n,m)%p;  (1<=m<=n<=10^9 ,m<=10^4,m<p<10^9);

 Lucas定理的运用。
 Lucas(n,m,p)=C(n%p,m%p)%p*Lucas(n/p,m/p,p); p为素数.
 
 {
 纠正一个错误
 for(i=1,j=n;i<=m;i++,j--)
 sum=(sum*j/i)%p;
 如果没有取模和溢出的条件下，这样做是可以的。
 但是，取模就不对啦。例子C(10,4)%107。
 }
 后来知道，用了一个叫做乘法逆元的东东。
【定义】若整数a,b,p, 满足a·b≡1(mod p).则称a 为b 模p 的乘法逆元, 即a=b- 1mod p.其中, p 是模数。
 乘法逆元有解的前提是gcd(b,p)=1;由于题意p为素数，那就肯定成立了.
 应用到组合数中来就是:
 a!/[b!*(a-b)!] % p == a! * [b!*(a-b)!]-1 %p 
 ???
 
**/
#include<iostream>
#include<stdio.h>
#include<cstring>
#include<cstdlib>
using namespace std;
typedef long long LL;

LL pow_mod(LL a,LL n,LL p)
{
    LL ans=1;
    while(n)
    {
        if(n&1) ans=(ans*a)%p;
        n=n>>1;
        a=(a*a)%p;
    }
    return ans;
}
void solve(LL n,LL m,LL p)
{
    LL i,sum1=1,sum2=1;
    for(i=0;i<m;i++)
    {
        sum1=(sum1*(n-i))%p;
        sum2=(sum2*(m-i))%p;
    }
    LL ans=(sum1*pow_mod(sum2,p-2,p))%p;
    printf("%lld\n",ans);
}
int main()
{
    int T;
    LL n,m,p;
    scanf("%d",&T);
    while(T--){
    scanf("%lld%lld%lld",&n,&m,&p);
    n=n%p;
    if(p==1){
        printf("0\n");
        continue;
    }
    solve(n,m,p);
    }
    return 0;
}