20171015 杂题

BZOJ[4563] [Haoi2016]放棋子

这个题是由套路的，可以直接用错排公式，首先f[1]=0,f[2]=1,然后考虑后面的转移，当放第i个的时候，前面的只可能是i-1个全部都不在自己的位置或者只有1个不在自己的位置，对于前者，第i个可以和前i-1个中的任意一个互换位置，贡献就是f[i-1]*(i-1),对于后者，第i个只能和在自己位置上的互换位置，贡献就是f[i-2]*(i-1);,然后套一个高精就行了

#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
int n;
void init(){int x;for(int i=1;i<=n;i++) for(int j=1;j<=n;j++) scanf("%d",&x);}
struct Bignum{
    int num[6000],len;
    Bignum(){memset(num,0,sizeof(num)); len=0;}
    void clear(){memset(num,0,sizeof(num)); len=0;}
    void pt(){
        for(int i=len;i>=1;i--){
            printf("%d",num[i]);
        } printf("
");
    }
};
Bignum c;
Bignum operator * (const Bignum a,const int b){
    c.clear(); int len=a.len;
    for(int i=1;i<=len;i++){
        c.num[i]+=a.num[i]*b;
        c.num[i+1]+=c.num[i]/10;
        c.num[i]%=10;
    }
    if(c.num[len+1]) len++;
    while(c.num[len]>10){
        c.num[len+1]+=c.num[len]/10;
        c.num[len]%=10;
        len++;
    }
    c.len=len; return c;
}
Bignum operator + (const Bignum a,const Bignum b){
    c.clear(); int len=a.len+b.len;
    for(int i=1;i<=len;i++){
        c.num[i]+=a.num[i]+b.num[i];
        c.num[i+1]+=c.num[i]/10;
        c.num[i]%=10;
    }
    if(c.num[len+1]) len++;
    while(!c.num[len]) len--;
    c.len=len; return c;
}
Bignum f[2010];
void work(){
    f[1].num[1]=0; f[1].len=1; f[2].num[1]=1;  f[2].len=1;
    for(int i=3;i<=n;i++){
        f[i]=(f[i-1]+f[i-2])*(i-1);
    }
    f[n].pt();
}
void tst(){
    Bignum a,b;
    a.len=1; a.num[1]=1;
    a=a*1234; a.pt();
    b=a; b=b+a; 
    b.pt();
}
int main(){
    scanf("%d",&n);
    init();
    work();
    return 0;
}

BZOJ[3170] [Tjoi 2013]松鼠聚会

可以神奇的把这个切比雪夫距离转化为曼哈顿距离（之前学长好想提到过一次），具体的证明还是挺简单的 http://blog.csdn.net/slongle_amazing/article/details/50911504

#include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
# define maxn 100010
using namespace std;
typedef long long LL;
int n;
struct node {
    LL x,y,sumx,sumy;
    node(){sumx=0; sumy=0;}
}g[maxn];
void init(){
    scanf("%d",&n);
    int x,y;
    for(int i=1;i<=n;i++){
        scanf("%d%d",&x,&y);
        g[i].x=x+y; g[i].y=x-y;
//        cout<<g[i].x<<"  "<<g[i].y<<endl;
    }
}
LL sum[maxn];
bool cmp1(const node a,const node b){return a.x<b.x;}
bool cmp2(const node a,const node b){return a.y<b.y;}
void work(){
    sort(g+1,g+n+1,cmp1);
    memset(sum,0,sizeof(sum));
    for(int i=1;i<=n;i++) sum[i]=sum[i-1]+(LL)g[i].x;
    for(int i=1;i<=n;i++){
        g[i].sumx+=g[i].x*(i-1)-sum[i-1];
        g[i].sumx+=(sum[n]-sum[i])-(n-i)*g[i].x;
    }
    sort(g+1,g+n+1,cmp2);
    memset(sum,0,sizeof(sum));
    for(int i=1;i<=n;i++) sum[i]=sum[i-1]+g[i].y;
    for(int i=1;i<=n;i++){
        g[i].sumy+=g[i].y*(i-1)-sum[i-1];
        g[i].sumy+=(sum[n]-sum[i])-(n-i)*g[i].y;
    }
    LL ans=0x7fffffffffffffffll;
    for(int i=1;i<=n;i++){
        ans=min(g[i].sumx+g[i].sumy,ans);
    }
    cout<<ans/2<<endl;
}
int main(){
//    freopen("a.in","r",stdin);
    init();
    work();
    return 0;
}

BZOJ[1079] [SCOI2008]着色方案

这个题可以用 记忆化搜索+哈希+map 水过，就是把每次剩下的所有颜色的个数除了上一个的颜色之外排序，然后哈希记录一下当前的贡献，当下次再遇到这个状态的时候，直接return就行了

#include <map>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
# define mod 1000000007
# define P 76543
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
void ot(){cout<<"****"<<endl;}
void fen(){cout<<"----------------------------"<<endl;}
ULL px[22];
void beg(){px[0]=1; for(int i=1;i<=20;i++) px[i]=px[i-1]*P;}
int n,tot;
int Num[20];
map<ULL,LL> ma;
bool cmp(const int a,const int b){return a<b;}
int cun[15];
ULL HS(int x,int lst){
    ULL ret=0;
    for(int i=1;i<=x;i++){
        ret+=cun[i]*px[i];
    }
    return ret;
}
LL dfs(int x,int lst){
    if(x==tot+1){ return 1; }
    int tip=0; ULL hs;
    for(int i=1;i<=n;i++){
        if(i==lst) continue;
        cun[++tip]=Num[i];
    }
    sort(cun+1,cun+tip+1,cmp); cun[++tip]=Num[lst]; 
    hs=HS(tip,lst);
    if(ma.count(hs)){return ma[hs];}
    LL now=0;
    for(int i=1;i<=n;i++){
        if(i==lst || !Num[i]) continue;
        Num[i]--;
        now+=dfs(x+1,i);
        now%=mod;
        Num[i]++;
    }
    ma[hs]=now;
    return now;
}
int main(){
//  freopen("a.in","r",stdin);
//  freopen("ce.out","w",stdout);
    scanf("%d",&n);
    beg();
    for(int i=1;i<=n;i++) scanf("%d",&Num[i]),tot+=Num[i];
    LL ans=dfs(1,-1);
    cout<<ans<<endl;
    return 0;
}

BZOJ[2839] 集合计数

这个题就是可以先从n个里面选出K个，然后考虑剩下的元素的组成的集合，互没有交集的方案数，

开始我想的是用一个f数组来递推，然后利用挡板法来求，后来发现并不能这么转移，因为有很多重复的情况没有办法去掉，然而正解是之前的题上试过很多次的不行的容斥原理，

用f[i]表示剩下的元素组成交集大小至少是i的方案数，因为至少要选择i个，那就先乘一个C(n-K,i);然后剩下的(n-i-K)个元素有2^(n-i-K)个子集，每一个集合都可以选或者不选，但是不能都不选，因为当前的含义是把调出来的K个放在这些集合里，然后就能得到f[i]=C(n-K,i)*2^(2^(n-i-K)),然后偶加奇减，乘C(n,K)就是答案了