Contest - ACdream原创群赛の妹子的假期生活 解题报告

总体情况：

昨天做的人不是很多啊T_T ， 以下是Board

感谢帮我验题的同学们：

本来想是覆盖所有知识点的，失败T_T ，木有出字符串，搜索也是图论过的T_T

P.S. 

本次解题报告代码要和http://blog.csdn.net/dslovemz/article/details/8435024 配套使用

A 孟竹的Triple

Dynamic Programming

仿照本次长春赛区H题出的一个题目。

状态是 dp[数个数][和][LCM][异或值]。不过这样肯定是要MLE+TLE的。于是两种优化：

1、数的个数，因为递推的时候只会从 i -> i + 1于是用滚动数组

2、LCM ， 预处理1~100所有数字的约数，以及两个约数LCM

typedef long long int64;

struct Int {
	int x;
	Int() :
			x(0) {
	}
	Int(int _x) :
			x(_x) {
		x %= MOD;
		if (x < 0)
			x += MOD;
	}
	Int(int64 _x) {
		x = _x % MOD;
		if (x < 0)
			x += MOD;
	}
	static Int get(int x) {
		Int a;
		a.x = x;
		return a;
	}

	Int operator+(const Int&o) const {
		int t = x + o.x;
		if (t >= MOD)
			t -= MOD;
		return get(t);
	}
	Int operator*(const Int&o) const {
		return get(1LL * x * o.x % MOD);
	}
	Int operator-(const Int&o) const {
		int t = x - o.x;
		if (t < 0)
			t += MOD;
		return get(t);
	}
	Int operator/(const Int&o) const {
		return (*this) * o.inv();
	}
	Int&operator+=(const Int&o) {
		return (*this) = *this + o;
	}
	Int&operator-=(const Int&o) {
		return (*this) = *this - o;
	}
	Int&operator*=(const Int&o) {
		return (*this) = *this * o;
	}
	Int&operator/=(const Int&o) {
		return (*this) = *this / o;
	}

	Int power(int64 n) const {
		if (!n)
			return get(1);
		const Int&a = *this;
		if (n & 1)
			return power(n - 1) * a;
		else
			return (a * a).power(n >> 1);
	}

	Int inv() const {
		return power(MOD - 2);
	}
};
/* .................................................................................................................................. */
Int dp[2][102][15][139];
VI Factor[101];
int FactorP[101][101] , lcmP[101][101][101] , FactorCnt[101];
int n , a , b , c;
void init(){
    for (int i = 0 ; i <= 100 ; ++i)
        Factor[i].clear();
    RST(FactorP);
    RST(lcmP);
    for (int i = 1 ; i <= 100 ; ++i){
        for (int j = 1 ; j <= i ; ++j)
            if (i % j == 0){
                Factor[i].PB(j);
                FactorP[i][j] = SZ(Factor[i]) - 1;
            }
        FactorCnt[i] = SZ(Factor[i]);
    }
    for (int i = 1 ; i <= 100 ; ++i){
        for (int j = 0 ; j < FactorCnt[i] ; ++j)
        for (int k = 0 ; k < FactorCnt[i] ; ++k){
            int p = Factor[i][j];
            int q = Factor[i][k];
            int r = p / GCD(p , q) * q;
            r = FactorP[i][r];
            lcmP[i][j][k] = r;
        }
    }
}
void solve(){
    RD(n , a , b , c);
    RST(dp);
    dp[0][0][0][0].x = 1;
    for (int i = 0 ; i < n ; ++i){
        int nw = i & 1;
        int nx = 1 - nw;
        for (int sum = 0 ; sum <= a ; ++sum)
        for (int lcmnow = 0 ; lcmnow < FactorCnt[b] ; ++lcmnow)
        for (int xorsum = 0 ; xorsum <= 128 ; ++xorsum)
            dp[nx][sum][lcmnow][xorsum].x = 0;
        for (int sum = 0 ; sum <= a ; ++sum)
        for (int lcmnow = 0 ; lcmnow < FactorCnt[b] ; ++lcmnow)
        for (int xorsum = 0 ; xorsum < 128 ; ++xorsum){
//                printf("dp[%d][%d][%d][%d] = %d\n" , nw , sum , lcmnow , xorsum , dp[nw][sum][lcmnow][xorsum]);
            if (dp[nw][sum][lcmnow][xorsum].x == 0) continue;
            for (int add = 0 ; add < FactorCnt[b] && Factor[b][add] + sum <= a; ++add){
                int addFactor = Factor[b][add];
//                printf("ADD dp[%d][%d][%d][%d] += %d\n" , nx , sum + addFactor , lcmP[b][lcmnow][add] , (xorsum ^ addFactor) , dp[nw][sum][lcmnow][xorsum].x);
                dp[nx][sum + addFactor][lcmP[b][lcmnow][add]][(xorsum ^ addFactor)] += dp[nw][sum][lcmnow][xorsum];
            }
        }
    }
    printf("%d\n" , dp[(n & 1)][a][FactorP[b][b]][c].x);
//    if (dp[(n & 1)][a][FactorP[b][b]][c].x) printf("%d %d %d %d\n" , n , a , b , c);
}
int main(){
    freopen("0.in" , "r" , stdin);
    freopen("0.out" , "w" , stdout);
    init();
    Rush solve();
}

B 孟竹的复习计划

动态求逆序对，树状数组 / 线段树。

这题其实是有一次我做CF的时候看错题了，突然想到的T_T

方法是开100棵树状数组，每次询问花100 * logn的时间，所以复杂度就是(n + m)*100 * logn

SEGMENT - TREE

#define lson l , m , rt << 1
#define rson m + 1 , r , rt << 1 | 1
const int maxn = 10009;
struct TREE{
    int tree[maxn<<2];
    void PushUP(int rt) {
        tree[rt] = (tree[rt<<1] + tree[rt<<1|1]);
    }
    void build(int l,int r,int rt) {
        if (l == r) {
            //scanf("%d",&tree[rt]);
            tree[rt] = 0;
            return ;
        }
        int m = (l + r) >> 1;
        build(lson);
        build(rson);
        PushUP(rt);
    }
    void update(int p,int sc,int l,int r,int rt) {
        if (l == r) {
            tree[rt] = sc;
            return ;
        }
        int m = (l + r) >> 1;
        if (p <= m) update(p , sc , lson);
        else update(p , sc , rson);
        PushUP(rt);
    }
    int query(int L,int R,int l,int r,int rt) {
        if (L <= l && r <= R) {
            return tree[rt];
        }
        int m = (l + r) >> 1;
        int ret = 0;
        if (L <= m) {
            int res= query(L , R , lson);
            ret += (res);
        }
        if (R > m) {
           int res= query(L , R , rson);
           ret += (res);
        }
        return ret;
    }
}tree[109];
int a[maxn] , n , m;
struct IO{
    int op , x , y;
    void input(){
        RD(op , x , y);
    }
}io[10009];
VI hashT;
VI edge[109];
MII hash;
int L;
int cal(int po , int val){
    int res = 0;
    for (int i = 1 ; i <= L ; ++i){
        if (i < val && po < n)
            res += tree[i].query(po + 1 , n , 1 , n , 1);
        if (i > val && po > 1)
            res += tree[i].query(1 , po - 1 , 1 , n , 1);
    }
    return res;
}
void changeNumber(int po , int val){
    tree[a[po]].update(po , 0 , 1 , n , 1);
    tree[val].update(po , 1 , 1 , n , 1);
}
void solve(){
    RD(n , m);
    hash.clear();
    hashT.clear();
    for (int i = 1 ; i <= n ; ++i) RD(a[i]) , hashT.PB(a[i]);
    for (int i = 1 ; i <= m ; ++i){
        io[i].input();
        if (io[i].op == 0) hashT.PB(io[i].y);
    }
    sort(ALL(hashT));
    L = unique(ALL(hashT)) - hashT.begin();
    for (int i = 0 ; i < L ; ++i)
        hash[hashT[i]] = i + 1 ;
    for (int i = 1 ; i <= n ; ++i) a[i] = hash[a[i]];
    for (int i = 1 ; i <= m ; ++i)
        if (io[i].op == 0)
            io[i].y = hash[io[i].y];
    for (int i = 0 ; i <= L ; ++i){
        tree[i].build(1 , n , 1);
        edge[i].clear();
    }

    for (int i = 1 ; i <= n ; ++i){
        edge[a[i]].PB(i);
    }

    int ans = 0;
    for (int i = 1 ; i <= L ; ++i){
        for (int j = 0 ; j < SZ(edge[i]) ; ++j){
            int now = edge[i][j];
            if (now < n) ans += tree[0].query(now + 1 , n , 1 , n , 1);
        }
        for (int j = 0 ; j < SZ(edge[i]) ; ++j){
            int now = edge[i][j];
            tree[0].update(now , 1 , 1 , n , 1);
        }
    }
    tree[0].build(1 , n , 1);
    for (int i = 1 ; i <= n ; ++i)
        tree[a[i]].update(i , 1 , 1 , n , 1);
    printf("%d\n" , ans);
    for (int cas = 1 ; cas <= m ; ++cas){
        int op = io[cas].op , x = io[cas].x , y = io[cas].y;
        int change = 0;
        if (op == 0){
            change -= cal(x , a[x]);
            change += cal(x , y);
            ans += change;
            changeNumber(x , y);
            a[x] = y;
        }
        else{
            if (x > y) swap(x , y);
            change -= cal(x , a[x]);
            change -= cal(y , a[y]);
            changeNumber(x , a[y]);
            changeNumber(y , a[x]);
            swap(a[x] , a[y]);
            change += cal(x , a[x]);
            change += cal(y , a[y]);
            if (a[x] > a[y]) change--;
            else if (a[x] < a[y]) change++;
            ans += change;
        }
        printf("%d\n" , ans);
    }
}
int main(){
//    freopen("0.in" , "r" , stdin);
//    freopen("segmengtree.out" , "w" , stdout);
    Rush solve();
}

BIT

const int maxn = 10009;
int n;
struct TREE{
    int tree[maxn] , cnt;
    void init(){
        RST(tree);
        cnt = 0;
    }
    void add(int po , int c){
        for ( ; po< maxn ; po += low_bit(po))
            tree[po] += c;
        cnt += c;
    }
    int query(int po){
        int ret = 0;
        for (; po > 0 ; po -= low_bit(po))
            ret += tree[po];
        return ret;
    }
}tree[109];
int a[maxn] , m;
struct IO{
    int op , x , y;
    void input(){
        RD(op , x , y);
    }
}io[10009];
VI hashT;
VI edge[109];
MII hash;
int L;
int cal(int po , int val){
    int res = 0;
    for (int i = 1 ; i <= L ; ++i){
        if (i < val && po < n)
            res += tree[i].cnt - tree[i].query(po - 1);
        if (i > val && po > 1)
            res += tree[i].query(po - 1);
    }
    return res;
}
void changeNumber(int po , int val){
    tree[a[po]].add(po , -1);
    tree[val].add(po , 1);
}
void solve(){
    RD(n , m);
    hash.clear();
    hashT.clear();
    for (int i = 1 ; i <= n ; ++i) RD(a[i]) , hashT.PB(a[i]);
    for (int i = 1 ; i <= m ; ++i){
        io[i].input();
        if (io[i].op == 0) hashT.PB(io[i].y);
    }
    sort(ALL(hashT));
    L = unique(ALL(hashT)) - hashT.begin();
    for (int i = 0 ; i < L ; ++i)
        hash[hashT[i]] = i + 1 ;
    for (int i = 1 ; i <= n ; ++i) a[i] = hash[a[i]];
    for (int i = 1 ; i <= m ; ++i)
        if (io[i].op == 0)
            io[i].y = hash[io[i].y];
    for (int i = 0 ; i <= L ; ++i){
        tree[i].init();
        edge[i].clear();
    }

    for (int i = 1 ; i <= n ; ++i){
        edge[a[i]].PB(i);
    }

    int ans = 0;
    for (int i = L ; i >= 1 ; --i){
        for (int j = 0 ; j < SZ(edge[i]) ; ++j){
            int now = edge[i][j];
            ans += tree[0].query(now);
        }
        for (int j = 0 ; j < SZ(edge[i]) ; ++j){
            int now = edge[i][j];
            tree[0].add(now , 1);
        }
    }
    tree[0].init();
    for (int i = 1 ; i <= n ; ++i)
        tree[a[i]].add(i , 1);
    printf("%d\n" , ans);
    for (int cas = 1 ; cas <= m ; ++cas){
        int op = io[cas].op , x = io[cas].x , y = io[cas].y;
        int change = 0;
        if (op == 0){
            change -= cal(x , a[x]);
            changeNumber(x , y);
            change += cal(x , y);
            ans += change;
            a[x] = y;
        }
        else{
            if (x > y) swap(x , y);
            change -= cal(x , a[x]);
            change -= cal(y , a[y]);
            changeNumber(x , a[y]);
            changeNumber(y , a[x]);
            swap(a[x] , a[y]);
            change += cal(x , a[x]);
            change += cal(y , a[y]);
            if (a[x] > a[y]) change--;
            else if (a[x] < a[y]) change++;
            ans += change;
        }
        printf("%d\n" , ans);
    }
}
int main(){
//    freopen("0.in" , "r" , stdin);
//    freopen("bit.out" , "w" , stdout);
    Rush solve();
}

XLK 的 二维BIT

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
#include<vector>
using namespace std;
#define fr(i,n) for(int i=0;i<n;i++)
#define fo(i,n) for(int i=1;i<=n;i++)
#define fe(i,n) for(__typeof(n.begin()) i=n.begin();i!=n.end();i++)
int c[105][10020];
int a[10020];
int n,m,z,t;
int R(int x,int y,int z)
{
    for(int i=x;i<=100;i+=i&-i)
        for(int j=y;j<=n;j+=j&-j)
            c[i][j]+=z;
}
int G(int x,int y)
{
    int _=0;
    for(int i=x;i;i-=i&-i)
        for(int j=y;j;j-=j&-j)
            _+=c[i][j];
    return _;
}
void C(int p,int x)
{
    R(a[p],p,-1);
    z-=G(100,p)-G(a[p],p);
    z-=G(a[p]-1,n)-G(a[p]-1,p);
    a[p]=x;
    R(a[p],p,+1);
    z+=G(100,p)-G(a[p],p);
    z+=G(a[p]-1,n)-G(a[p]-1,p);
}
int main()
{
    for(scanf("%d",&t);t--;)
    {
        z=0;
        memset(c,0,sizeof c);
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++)
        {
            scanf("%d",a+i);
            z+=G(100,i)-G(a[i],i);
            R(a[i],i,1);
        }
        printf("%d\n",z);
        for(int i=0;i<m;i++)
        {
            int o,x,y;
            scanf("%d%d%d",&o,&x,&y);
            if(o==1)
            {
                int ax=a[x],ay=a[y];
                C(x,ay);
                C(y,ax);
            }
            else
            {
                C(x,y);
            }
            printf("%d\n",z);
        }
    }
}

C 孟竹的幼儿园生活

简单计算几何。

分成两部分：

1、给正方形对角线，求四个角——模板

2、HPI ， nlogn半平面交

XLK 的代码

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<math.h>
const double inf=1e8;
const double eps=1e-8;
const double pi=acos(-1.);
using namespace std;
struct P
{
    double x,y;
    P(){}
    P(double x,double y):x(x),y(y){}
    void scan()
    {
        scanf("%lf %lf",&x,&y);
    }
    void print(string s="")
    {
        if(s!="")
            cout << s << ": ";
        printf("%.2f %.2f\n",x,y);
    }
    double dis(const P&a)
    {
        return hypot(x-a.x,y-a.y);
    }
    P rot(double f)
    {
        double sf=sin(f),cf=cos(f);
        return P(x*cf-y*sf,y*cf+x*sf);
    }
    double dot(const P&a)
    {
        return x*a.x+y*a.y;
    }
    double det(const P&a)
    {
        return x*a.y-y*a.x;
    }
}p[4020],s[4020],o;
    bool operator==(const P&a,const P&b)
    {
        return fabs(a.x-b.x)<eps&&fabs(a.y-b.y)<eps;
    }
    bool operator!=(const P&a,const P&b)
    {
        return !(a==b);
    }
    bool operator<(const P&a,const P&b)
    {
        if(fabs(a.x-b.x)<eps)
            return a.y<b.y;
        return a.x<b.x;
    }
    P operator+(const P&a,const P&b)
    {
        return P(a.x+b.x,a.y+b.y);
    }
    P operator-(const P&a,const P&b)
    {
        return P(a.x-b.x,a.y-b.y);
    }
    P operator/(const P&a,double f)
    {
        return P(a.x/f,a.y/f);
    }
    P operator*(const P&a,double f)
    {
        return P(a.x*f,a.y*f);
    }
int pc,sc;
double r;
int sgn(double x)
{
    return (x>eps)-(x<-eps);
}
double xm(P a,P b,P c)
{
    return (b.x-a.x)*(c.y-a.y)-(c.x-a.x)*(b.y-a.y);
}
P cp(P as,P ae,P bs,P be)
{
    P re;
    double u=xm(as,ae,bs);
    double v=xm(ae,as,be);
    re.x=(bs.x*v+be.x*u)/(u+v);
    re.y=(bs.y*v+be.y*u)/(u+v);
    return re;
}
void ins(P a,P b)
{
    int i;
    sc=0;
    for(i=1;i<pc;i++)
    {
        if(sgn(xm(a,b,p[i]))>=0)
            s[++sc]=p[i];
        if(sgn(xm(a,b,p[i])*xm(a,b,p[i+1]))<0)
            s[++sc]=cp(a,b,p[i],p[i+1]);
    }
    pc=sc;
    if(sc==0)
        return;
    memcpy(p,s,sizeof(p));
    p[++pc]=p[1];
    return;
}
void mov(P a,P b,P&c,P&d)
{
    P o=P(a.y-b.y,b.x-a.x);
    double l=sqrt(o.x*o.x+o.y*o.y);
    o.x=o.x/l*r;
    o.y=o.y/l*r;
    c.x=a.x+o.x;
    c.y=a.y+o.y;
    d.x=b.x+o.x;
    d.y=b.y+o.y;
    return;
}
double dis(P a,P b)
{
    return (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y);
}
double S(P p[],int n)
{
    double re=0;
    int i;
    for(i=1;i<n;i++)
        re+=xm(o,p[i],p[i+1]);
    return fabs(re/2);
}
int main()
{
    int t;
    for(scanf("%d",&t);t--;)
    {
        int n,i,j,ans1,ans2;
        double ans=0,ds;
        scanf("%d",&n);
        p[1]=P(-10000,-10000);
        p[2]=P(10000,-10000);
        p[3]=P(10000,10000);
        p[4]=P(-10000,10000);
        p[pc=5]=p[1];
        for(i=1;i<=n;i++)
        {
            P u,v,o,p,q;
            u.scan();
            v.scan();
            o=(u+v)/2;
            p=(u-o).rot(pi/2)+o;
            q=(v-o).rot(pi/2)+o;
            ins(u,p);
            ins(p,v);
            ins(v,q);
            ins(q,u);
        }
        printf("%.4f\n",S(p,pc));
    }
    return 0;
}

D 孟竹跪DP

也是一个CF的原题。方法是枚举每个数字，记录左边离这个数字最近的二进制第i位是0或者1的数字的位置，暴力优化。复杂度O(n)

bool ans[2000000];
int MI[31];
void init(){
    for (int i = 0 ; i <= 29 ; ++i)
        MI[i] = 1 << i;
}
int n;
struct Meng{
    int t , po;
    bool operator < (const Meng & A) const{
        if (po != A.po) return po > A.po;
        return t < A.t;
    }
}dp0[31] , dp1[31];
const int ALL = (1 << 21) - 1;
bool cmp(Meng A , Meng B){
    return A.t < B.t;
}
#define LIMIT 21
int po0[LIMIT + 1] , po1[LIMIT + 1];
void solve(){
    RD(n);
    RST(ans);
//cout << ALL << endl;
    for (int i = 0 ; i < LIMIT ; ++i){
        dp0[i].t = i , dp1[i].t = i;
        dp0[i].po = -1 , dp1[i].po = -1;
    }
    for (int i = 0 ; i < n ; ++i){
        int x , y , z;
        RD(x);y = x , z = x;
        ans[x] = 1;
        for (int j = 0 ; j < LIMIT ; ++j){
            po0[dp0[j].t] = j;
            po1[dp1[j].t] = j;
        }
        for (int j = 0 ; j < LIMIT ; ++j){
            if(x & 1) dp1[po1[j]].po = i;
            else dp0[po0[j]].po = i;
            x >>= 1;
        }
        sort(dp0 , dp0 + LIMIT);
        sort(dp1 , dp1 + LIMIT);
//cout << i << endl;
        for(int j = 0 ; j < LIMIT ; ++j){
            if (dp0[j].po != -1){
//cout << "0"<<j<<endl;
//cout << dp0[j].t<<endl;
                y &= (ALL ^ MI[dp0[j].t]);
                if (j == LIMIT - 1 || dp0[j].po != dp0[j + 1].po){
//cout << y << endl;
                    ans[y] = 1;
                }
            }
            if (dp1[j].po != -1){
//cout << "1"<<j<<endl;
                z |= MI[dp1[j].t];
                if (j == LIMIT - 1 || dp1[j].po != dp1[j + 1].po){
//cout << z << endl;
                    ans[z] = 1;
                }
            }
        }
    }
//cout << "DS" << endl;
    int ANS = 0;
    for (int i = 0 ; i < 2000000 ; ++i)
        if (ans[i]) {
//cout << i << endl;
                ++ANS;
        }
    printf("%d\n" , ANS);
}
int main(){
    freopen("0.in" , "r" , stdin);
    freopen("0.out" , "w" , stdout);
    init();
    Rush solve();
}

E 孟竹和屌丝玩儿游戏

双指针+数据结构

首先，如果要求和不大于K的话，双指针就可以解决问题。

其次如果孟竹有必胜条件的话，那么异或值肯定不能为0。反过来算，求有多少个异或为0然后用C[n][2]剪掉即可。

怎么算呢？很简单，计算所有的前缀异或值。比如当前的前缀异或为A，之前到第j个位置异或也为A，A^A = 0 ，于是j+1 -> 当前位置这段区间的异或就为0

对于0的情况要特殊讨论，因为如果前缀和 <=k 的话异或为0是要加一的否则不加

int n ;
const int N = 1e5 + 9;
LL a[N];
map<LL , LL> hash;
LL k , sum , ans;
void solve(){
    RD(n);
    RD(k);
    for (int i = 0 ; i < n ; ++i)
        RD(a[i]);
    hash.clear();
    hash[0] = 0;
    int tail = 0;
    ans = 0;
    sum = 0;
    LL xorsum = 0 , xortail = 0;
    LL ALL = 0;
    for (int i = 0 ; i < n ; ++i){
        sum += a[i];
        xorsum ^= a[i];
        if (hash.find(xorsum) == hash.end()) hash[ xorsum ] = 1;
        else hash[ xorsum ] = hash[ xorsum ] + 1;
        while (sum > k) {
                sum -= a[tail];

//                if(hash.find(xortail) == hash.end()) printf("%d %d\n" , i , tail);
                assert(hash.find(xortail) != hash.end());
                xortail ^= a[tail];
                hash[xortail] = hash[xortail ]  - 1;

                ++tail;
        }
        ALL += i - tail + 1;
//        if (hash.find(xorsum) != hash.end())
        assert(hash.find(xorsum) != hash.end());
        if (tail == 0) ++ hash[0];
        else ++hash[(xortail)];
        if (tail <= i)
            ans += hash[ xorsum ] - 1ll;
        if (tail == 0) -- hash[0];
        else --hash[(xortail)];
//        cout <<"ANS:" <<  ans << endl;
    }
//    cout << ALL <<endl;
    ans = ALL - ans;
    OT(ans);
}
int main(){
//    freopen("0.in" , "r" , stdin);
//    freopen("0.out" , "w" , stdout);
    Rush solve();
}

F 孟竹要减肥？

并查集

将所有边长计算出来，从小到大加边，用并查集统计连通性，如果有一个 >= m 的连通块就结束

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include<math.h>
using namespace std;
const int N = 600;
namespace ufset{
    int fa[N] , rank[N] , SZ[N];
    void init(){
        for (int i = 0 ; i < N ; ++i) SZ[i] = 1 , fa[i] = i , rank[i] = 0;
    }
    int findset(int x){
        int r = x , y ;
        while(fa[r] != r) r = fa[r];
        while(fa[x] != r) {y = fa[x] , fa[x] = r , x = y;}
        return r;
    }
    void __unionset(int x , int y){
        if (rank[x] > rank[y]) {
                fa[y] = x;
                SZ[x] += SZ[y];
        }
        else {
            fa[x] = y;
            SZ[y] += SZ[x];
            if (rank[x] == rank[y]) ++ rank[y];
        }
    }
    void unionset(int x , int y){
        int rx = findset(x) , ry = findset(y);
        if (rx != ry) __unionset(rx , ry);
    }
}using namespace ufset;
struct Point{
    double x , y;
    void input(){
        scanf("%lf%lf" , &x , &y);
    }
    #define sqr(x) ((x) * (x))
    double dis(const Point & A) const{
        return sqrt(sqr(x - A.x) + sqr(y - A.y));
    }
}p[509];
int n , m ;
const double eps = 1e-8;
int dcmp(double d){
    if (fabs(d) < eps) return 0;
    return d < 0 ? -1 : 1;
}
struct Rel{
    int p , q;
    double nk;
    bool operator < (const Rel & A) const{
        return dcmp(nk - A.nk) < 0;
    }
}relation[509 * 509];
void solve(){
    scanf("%d%d" , &n,&m);
    for (int i = 0 ; i < n ; ++i) p[i].input();
    int rcnt = 0;
    for (int i = 0 ; i < n ; ++i)
    for (int j = i + 1 ; j < n ; ++j){
        relation[rcnt].p = i;
        relation[rcnt].q = j;
        relation[rcnt].nk = p[i].dis(p[j]);
        rcnt++;
    }
    sort(relation , relation + rcnt);
    init();
    for (int i = 0 ; i < rcnt ; ++i){
        unionset(relation[i].p , relation[i].q);
        int rx = findset(relation[i].p) , ry = findset(relation[i].q);
        if (SZ[rx] >= m || SZ[ry] >= m){
            printf("%.4lf\n" , relation[i].nk);
            return;
        }
    }
}
int main(){
    freopen("0.in" , "r" , stdin);
    freopen("0.out" , "w" , stdout);
    int T;
    scanf("%d" , &T);
    while(T--) solve();
}

G 孟竹的星星

水题。

标程的算法是计算出外心，然后随便找一个点，每次旋转72度即可。

看xlk的代码：

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
#include<vector>
#include<math.h>
using namespace std;
#define fr(i,n) for(int i=0;i<n;i++)
#define fo(i,n) for(int i=1;i<=n;i++)
#define fe(i,n) for(__typeof(n.begin()) i=n.begin();i!=n.end();i++)
 
    const double eps=1e-4;
    const double pi=acos(-1.);
    struct P
    {
        double x,y;
        P(){}
        P(double x,double y):x(x),y(y){}
        void scan()
        {
            scanf("%lf %lf",&x,&y);
        }
        void print(string s="")
        {
            if(s!="")
                cout << s << ": ";
            printf("%.2f %.2f\n",x,y);
        }
        double dis(const P&a)
        {
            return hypot(x-a.x,y-a.y);
        }
        P rot(double f)
        {
            double sf=sin(f),cf=cos(f);
            return P(x*cf-y*sf,y*cf+x*sf);
        }
        double dot(const P&a)
        {
            return x*a.x+y*a.y;
        }
        double det(const P&a)
        {
            return x*a.y-y*a.x;
        }
    };
    bool operator==(const P&a,const P&b)
    {
        return fabs(a.x-b.x)<eps&&fabs(a.y-b.y)<eps;
    }
    bool operator!=(const P&a,const P&b)
    {
        return !(a==b);
    }
    bool operator<(const P&a,const P&b)
    {
        if(fabs(a.x-b.x)<eps)
            return a.y<b.y;
        return a.x<b.x;
    }
    P operator+(const P&a,const P&b)
    {
        return P(a.x+b.x,a.y+b.y);
    }
    P operator-(const P&a,const P&b)
    {
        return P(a.x-b.x,a.y-b.y);
    }
    P operator/(const P&a,double f)
    {
        return P(a.x/f,a.y/f);
    }
    P operator*(const P&a,double f)
    {
        return P(a.x*f,a.y*f);
    }
    int sgn(double x)
    {
        return x<-eps?-1:x>eps;
    }
    namespace triangle
    {
        P circumcenter(const P&a,const P&b,const P&c)
        {
            double x1=a.x,y1=a.y,x2=b.x,y2=b.y,x3=c.x,y3=c.y;
            double s1=x1*x1+y1*y1,s2=x2*x2+y2*y2,s3=x3*x3+y3*y3;
            double rx=(y1*(s2-s3)+y2*(s3-s1)+y3*(s1-s2))/(x1*(y2-y3)+x2*(y3-y1)+x3*(y1-y2));
            double ry=(x1*(s2-s3)+x2*(s3-s1)+x3*(s1-s2))/(x1*(y2-y3)+x2*(y3-y1)+x3*(y1-y2));
            return P(-rx/2,ry/2);
        }
        P barycenter(const P&a,const P&b,const P&c)
        {
            return (a+b+c)/3;
        }
        pair<P,double>excircle(const P&a,const P&b,const P&c)
        {
            P p=circumcenter(a,b,c);
            return make_pair(p,p.dis(a));
        }
    }
int main()
{
    int t,ss;
    P a,b,c,d,e,w,r,p[5],s[3];
    for(scanf("%d",&t);t--;)
    {
        a.scan();
        b.scan();
        c.scan();
        w=triangle::circumcenter(a,b,c);
        r=w-a;
        ss=0;
        p[0]=a;
        for(int i=1;i<5;i++)
            p[i]=(p[i-1]-w).rot(2*pi/5)+w;
        for(int i=0;i<5;i++)
            if(p[i]!=a&&p[i]!=b&&p[i]!=c)
                s[ss++]=p[i];
        sort(s,s+ss);
        for(int i=0;i<2;i++)
            s[i].print();
    }
    return 0;
}

H 孟竹开Party

其实本题本意是想藏起来DLX算法然后让大家用图论方法搞不定的。。。但是貌似图论也可以

先说标程解法——用一遍dfs（复杂度O(VE)）来计算出来每个人直接 /  间接能Hold 住的人，然后就是 经典的可重复覆盖问题 。 中间如果一个人选择了，那么他的配偶就不能选择。

const int head=0;
//const int INF=10000000;
const int maxn = 610;
const int maxd = 1000000;
int N, M, K,  cnt, res;
int mat[maxn][maxn], s[maxn], l[maxd], r[maxd], u[maxd], d[maxd], c[maxd], o[maxn], row[maxd];
bool use[maxn];
void makegragh(int &n, int &m)
{
    memset(mat, 0, sizeof(mat));
//初始化mat矩阵
}
void initial(int n, int m)
{
    memset(use, false, sizeof(use));
    res=n+1;
    int i, j, rowh;
    memset(s, 0, sizeof(s));
    for(i=head; i<=m; i++)
    {
        r[i]=(i+1)%(m+1);
        l[i]=(i-1+m+1)%(m+1);
        u[i]=d[i]=i;
    }
    cnt=m+1;
    for(i=1; i<=n; i++)
    {
        rowh=-1;
        for(j=1; j<=m; j++)
        {
            //printf("%d", mat[i][j]);
            if(mat[i][j])
            {
                s[j]++;
                u[cnt]=u[j];
                d[u[j]]=cnt;
                u[j]=cnt;
                d[cnt]=j;
                row[cnt]=i;
                c[cnt]=j;
                if(rowh==-1)
                {
                    l[cnt]=r[cnt]=cnt;
                    rowh=cnt;
                }
                else
                {
                    l[cnt]=l[rowh];
                    r[l[rowh]]=cnt;
                    r[cnt]=rowh;
                    l[rowh]=cnt;
                }
                cnt++;
            }
        }
        //puts("");
    }
}
void remove(int c)
{
    for(int i=d[c]; i!=c; i=d[i])
    {
        r[l[i]]=r[i];
        l[r[i]]=l[i];
    }
}
void resume(int c)
{
    for(int i=d[c]; i!=c; i=d[i])
        r[l[i]]=l[r[i]]=i;
}
int h()
{
    bool has[maxn];
    memset(has, false, sizeof(has));
    int ans=0;
    for(int i=r[head]; i!=head; i=r[i])
        if(!has[i])
        {
            ans++;
            for(int j=d[i]; j!=i; j=d[j])
                for(int k=r[j]; k!=j; k=r[k])
                    has[c[k]]=true;
        }
    return ans;
}
int marrige[maxn];
bool dfs(int k)
{
    if(k+h()>=res)return false;//A* cut

    if(r[head]==head)
    {
        if(k<res) res=k;
        return true;
    }
    int ms=INF, cur=0;
    for(int t=r[head]; t!=head; t=r[t])
        if(s[t]<ms)
        {
            ms=s[t];
            cur=t;
        }
    for(int i=d[cur]; i!=cur; i=d[i])
    {
        int rr = row[i];
        if (marrige[rr] == 0 || use[marrige[rr]] == 0) use[rr] = 1;
        else continue;
//        int rr = (row[i] - 1) / 2 + 1;
//        if (!use[rr]) use[rr] = true;
//        else continue;
        remove(i);
        for(int j=r[i]; j!=i; j=r[j])
        {
            remove(j);
            s[c[j]]--;
        }
        dfs(k+1);
        for(int j=l[i]; j!=i; j=l[j])
        {
            resume(j);
            s[c[j]]++;
        }
        use[rr] = false;
        resume(i);
    }
    return false;
}
int n , m;
int P , x , y;
VI edge[maxn];
void vdfs(int now , int x){
    mat[x][now] = 1;
    ECH(it , edge[now]){
        int go = *it;
        if (!mat[x][go]) vdfs(go , x);
    }
}
void solve(){
    RST(marrige);
    RST(mat);
    RD(n , m);
//    printf("%d %d :" , n , m);
    for (int i = 1 ; i <= n + m ; ++i) edge[i].clear();
    for (int i = 1 ; i <= n + m ; ++i)
        edge[i].PB(i);
    RD(P);
    DO(P){
        RD(x , y);
        //mat[x][n + y] = 1;
        edge[x].PB(n + y);
    }
    RD(P);
    DO(P){
        RD(x , y);
        //mat[n + x][y] = 1;
        edge[n + x].PB(y);
    }
    RD(P);
    DO(P){
        RD(x , y);
        marrige[x] = y + n;
        marrige[y + n] = x;
    }
    for(int i = 1 ; i <= n + m ; ++i){
        vdfs(i , i);
    }
//    for (int i = 1 ; i <= n + m ; ++i){
//        for (int j = 1 ; j <= n + m ; ++j)
//            printf("%d " , mat[i][j]);
//        cout << endl;
//    }
    initial(n + m , n + m);
//    cout << "DS" << endl;
    dfs(0);
    cout << res << endl;
}
int main(){
    freopen("0.in" , "r" , stdin);
    freopen("0.out" , "w" , stdout);
    Rush solve();
}

XLK童鞋的解法是：计算出所有强连通块儿，如果每个入度为0的scc大小都大于1，那么一定有解。贪心就是看只有一个点的scc必须取。。然后如果他有情侣。。他情侣的scc就把他情侣去掉。。一直这样。。看看会不会出现擦掉之后他情侣的scc就没有别的点了

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
using namespace std;
#define fr(i,n) for(int i=0;i<n;i++)
#define fo(i,n) for(int i=1;i<=n;i++)
#define fe(i,n) for(__typeof(n.begin()) i=n.begin();i!=n.end();i++)
int t,n,m,p,q,w,scc,x,y,in[2020];
int low[2020],dfn[2020],cnt;
int v[2020],r[2020],s[2020],ss;
int f[2020],z;
vector<int>a[2020];
set<int>se[2020];
int dfs(int x)
{
    dfn[x]=low[x]=++cnt;
    s[ss++]=x;
    v[x]=1;
    fe(i,a[x])
    {
        if(!dfn[*i])
        {
            dfs(*i);
            low[x]=min(low[x],low[*i]);
        }
        else if(v[*i])
        {
            low[x]=min(low[x],dfn[*i]);
        }
    }
    if(dfn[x]==low[x])
    {
        scc++;
        do
        {
            v[s[ss-1]]=0;
            r[s[ss-1]]=scc;
            se[scc].insert(s[ss-1]);
//          c[scc]++;
        }
        while(s[--ss]!=x);
    }
    return 0;
}
int main()
{
    for(scanf("%d",&t);t--;)
    {
        scc=0;
        cnt=0;
        z=0;
        memset(in,0,sizeof in);
        memset(f,0,sizeof f);
        memset(low,0,sizeof low);
        memset(dfn,0,sizeof dfn);
        memset(v,0,sizeof v);
        memset(r,0,sizeof r);
        scanf("%d%d",&n,&m);
        for(int i=1;i<=m+n;i++)
            a[i].clear();
        for(int i=1;i<=m+n;i++)
            se[i].clear();
        scanf("%d",&p);
        for(int i=0;i<p;i++)
        {
            scanf("%d%d",&x,&y);
            a[x].push_back(y+n);
        }
        scanf("%d",&q);
        for(int i=0;i<q;i++)
        {
            scanf("%d%d",&x,&y);
            a[x+n].push_back(y);
        }
        scanf("%d",&w);
        for(int i=0;i<w;i++)
        {
            scanf("%d%d",&x,&y);
            f[x]=y+n;
            f[y+n]=x;
        }
        for(int i=1;i<=m+n;i++)
            if(!dfn[i])
                dfs(i);
        queue<int>q;
        for(int i=1;i<=m+n;i++)
            fe(j,a[i])
                if(r[i]!=r[*j])
                    in[r[*j]]++;
        for(int i=1;i<=m+n;i++)
            if(se[r[i]].size()==1&&in[r[i]]==0)
                q.push(i);
        for(int i=1;i<=scc;i++)
            if(in[i]==0)
                z++;
        while(q.size())
        {
            int u=q.front();
            q.pop();
            if(f[u]&&in[r[f[u]]]==0)
            {
                se[r[f[u]]].erase(f[u]);
                if(se[r[f[u]]].size()==0)
                {
                    printf("%d\n",n+m+1);
                    goto end;
                }
                else if(se[r[f[u]]].size()==1)
                {
                    q.push(*se[r[f[u]]].begin());
                }
            }
        }
        printf("%d\n",z);
        end:;
    }
}

I 孟竹画圈圈诅咒你

没啥好说的，标准数学题。

typedef long long int64;

struct Int {
	int x;
	Int() :
			x(0) {
	}
	Int(int _x) :
			x(_x) {
		x %= MOD;
		if (x < 0)
			x += MOD;
	}
	Int(int64 _x) {
		x = _x % MOD;
		if (x < 0)
			x += MOD;
	}
	static Int get(int x) {
		Int a;
		a.x = x;
		return a;
	}

	Int operator+(const Int&o) const {
		int t = x + o.x;
		if (t >= MOD)
			t -= MOD;
		return get(t);
	}
	Int operator*(const Int&o) const {
		return get(1LL * x * o.x % MOD);
	}
	Int operator-(const Int&o) const {
		int t = x - o.x;
		if (t < 0)
			t += MOD;
		return get(t);
	}
	Int operator/(const Int&o) const {
		return (*this) * o.inv();
	}
	Int&operator+=(const Int&o) {
		return (*this) = *this + o;
	}
	Int&operator-=(const Int&o) {
		return (*this) = *this - o;
	}
	Int&operator*=(const Int&o) {
		return (*this) = *this * o;
	}
	Int&operator/=(const Int&o) {
		return (*this) = *this / o;
	}

	Int power(int64 n) const {
		if (!n)
			return get(1);
		const Int&a = *this;
		if (n & 1)
			return power(n - 1) * a;
		else
			return (a * a).power(n >> 1);
	}

	Int inv() const {
		return power(MOD - 2);
	}
};

/* .................................................................................................................................. */
Int D(Int n){
    Int ret;
    ret = n * (n + 1) / 2;
    ret = ret + 1;
    return ret;
}
void solve(){
    char op[2];
    Int n , ans;
    scanf("%s%d" , op , &n.x);
    if (op[0] == 'L'){
        ans = D(n);
        //cout << ans.x << endl;
        OT(ans.x);
    }
    else if (op[0] == 'V'){
        ans = D(n * 2);
        ans = ans - n * 2;
        //cout << ans.x << endl;
        OT(ans.x);
    }
    else if (op[0] == 'Z'){
        ans = D(n * 3);
        ans = ans - n * 5;
        //cout << ans.x << endl;
        OT(ans.x);
    }
}
int main(){
    freopen("0.in" , "r" , stdin);
    freopen("0.out" , "w" , stdout);
    Rush solve();
}

cxlove 的代码：

#include<iostream>
#include<cstdio>
#include<map>
#include<cstring>
#include<cmath>
#include<vector>
#include<algorithm>
#include<set>
#include<string>
#include<queue>
#define inf 1000000005
#define M 40
#define N 100005
#define maxn 300005
#define eps 1e-12
#define zero(a) fabs(a)<eps
#define Min(a,b) ((a)<(b)?(a):(b))
#define Max(a,b) ((a)>(b)?(a):(b))
#define pb(a) push_back(a)
#define mp(a,b) make_pair(a,b)
#define mem(a,b) memset(a,b,sizeof(a))
#define LL long long
#define MOD 1000000009
#define lson step<<1
#define rson step<<1|1
#define sqr(a) ((a)*(a))
#define Key_value ch[ch[root][1]][0]
#define test puts("OK");
#define pi acos(-1.0)
#define lowbit(x) ((-(x))&(x))
#define HASH1 1331
#define HASH2 10001
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
LL a,b,c;
int main(){
    //freopen("input.txt","r",stdin);
    int  t;
    char str[10];
    cin>>t;
    while(t--){
        scanf("%s%d" , str , &a);
        LL ans;
        if(str[0]=='L') ans=(a*(a+1)/2 + 1)%MOD;
        else if(str[0]=='V') ans=(2*a*(2*a+1)/2+1-2*a)%MOD;
        else ans=(3*a*(3*a+1)/2+1-5*a)%MOD;
        cout<<ans<<endl;
    }
    return 0;
}

J 孟竹搭积木

这题数据有错误貌似，大家抱歉了。

方法是状态压缩DP + 矩阵乘法 + 枚举 + 记忆化搜索

先说做法吧——

1、状态压缩，把一层的占有方法用2^7的一个向量记录。

2、暴力枚举第一层的情况，将只有一层的每个状态拼接方法数计算出来——initial P

3、记忆化搜索+枚举计算出转移矩阵Q，即从i层状态转移到第i层填满并且i+1层的另一个状态的转移方案数——initial Q

4、矩阵乘法，计算 P * (E + Q + Q^2 +... + Q^(N))

我的代码（虽然有错，方法是对的T_T）

const int MATN = 129;
const LL modo = MOD;
struct Mat{
    int Matn , Matm;
    LL a[MATN][MATN];
    Mat(){
        Matn = 0;
        Matm = 0;
        memset(a , 0 , sizeof(a));
    }
    void output(){
        cout << "OUTPUT" << endl;
        for (int i = 0 ; i < Matn ; ++i){
            for (int j = 0 ; j < Matm ; ++j){
                printf("%lld ",a[i][j]);
            }
            printf("\n");
        }
    }
    void init(){
        Matn = 0;Matm = 0;
        memset(a , 0 , sizeof(a));
    }
    Mat operator + (const Mat & A) const{
        Mat ret = A;
        for (int i = 0 ; i < Matn ; ++i){
            for (int j = 0 ; j < Matm ; ++j)
                ret.a[i][j] = (ret.a[i][j] + a[i][j]) % modo;
        }
        return ret;

    }
    Mat operator * (const Mat & A) const{
        Mat c ;
        c.Matn = Matn;
        c.Matm = A.Matm;
        for (int i = 0 ; i < Matn ; ++i)
            for (int j = 0 ; j < A.Matm ; ++j)
                for (int k = 0 ; k < Matm ; ++k)
                    c.a[i][j] = (c.a[i][j] + (a[i][k] * A.a[k][j])%modo)%modo;
        return c;
    }
    void initI(){
        memset(a, 0 , sizeof(a));
        for (int i = 0 ; i < Matn ; ++i)
            a[i][i] = 1;
    }
    Mat power(LL k){
        Mat c = *this  , b;
        b.init();
        b.Matn = Matn ; b.Matm = Matm;
        b.initI();
        while(k){
            if (k & 1LL)
                b = b * c;
            c = c * c;
            k >>= 1LL;
        }
        return b;
    }
}QQ;
struct ZHU{
    Mat a[2][2];
    void init(const Mat& p){
        for (int i = 0 ; i < 2 ; ++i)
            for (int j=  0 ; j < 2 ;++j){
                a[i][j].init();
                a[i][j].Matn = 128 ; a[i][j].Matm = 128;
            }
        a[0][0] = p;
        a[0][1].initI();
        a[1][1].initI();
    }
    void initI(){
        for (int i = 0 ; i < 2 ; ++i)
            for (int j=  0 ; j < 2 ;++j){
                a[i][j].Matn = 128 ; a[i][j].Matm = 128;
                a[i][i].initI();
            }
    }
    ZHU operator * (const ZHU & A) const{
        ZHU res;
        for (int i = 0 ; i < 2 ; ++i)
            for (int j= 0 ; j < 2 ;++j){
                res.a[i][j].init();
                res.a[i][j].Matn = 128 ; res.a[i][j].Matm = 128;
            }
        for (int i = 0 ; i < 2 ; ++i)
            for (int j = 0 ; j < 2 ; ++j)
                for (int k = 0 ; k < 2 ; ++k)
                    res.a[i][j] = (res.a[i][j] + a[i][k] * A.a[k][j]);
        return res;
    }
    void copy(const ZHU & A) {
        for(int i = 0 ; i < 2 ; ++i)
            for (int j = 0 ; j < 2 ; ++j)
                a[i][j] = A.a[i][j];
    }
    Mat power(LL k);
}R , nR , b , c;
Mat ZHU::power(LL k){
//    printf("\nINT ");
//    cout << k << endl;
    c = *this;
    bool f = false;
    while(k){
        if (k & 1LL){
            if (!f) b = c;
            else b = b * c;
            f = true;
        }
        c = c * c;
        k >>= 1LL;
    }
    if (!f){
        b = c;
        b.a[0][1].initI();
    }
    return b.a[0][1];
}
const int PCODE[] = {0 , 1 , 2 , 4 , 8 , 16 , 32 , 64 , 0};
struct Under{
    bool mp[3][3];
    int hash;
    int encode(){
        hash = 0;
        for (int i = 0 ; i < 3 ; ++i)
            for(int j = 0 ; j < 3 ; ++j)
                if (mp[i][j])
                    hash |= PCODE[i * 3 + j];
        return hash;
    }
    void decode(){
        RST(mp);
        for (int i = 0 ; i < 3 ; ++i)
        for(int j = 0 ; j < 3 ; ++j){
            if (i + j == 0 || i + j == 4) continue;
            if (hash & (PCODE[i * 3 + j]))
                mp[i][j] = true;
            else mp[i][j] = false;
        }
    }
    void output(){
        printf("  %d %d\n", mp[0][1] , mp[0][2]);
        printf("%d %d %d\n" , mp[1][0] , mp[1][1] , mp[1][2]);
        printf("%d %d\n", mp[2][0] , mp[2][1]);
    }
    void input(){
        for(int i = 0 ; i < 3 ; ++i)
        for (int j = 0 ; j < 3 ; ++j){
            if (i + j == 0 || i + j == 4) continue;
            int x;
            RD(x);
            mp[i][j] = x;
        }
        encode();
    }

}en , temp;
LL n;
Mat P , Q ;
void solve(){
    RD(n);
    en.input();
    Mat nP = P;
//    nP.output();
    nR.copy(R);
//    nR.a[0][1].output();
//    printf("N %lld\n" , n);
    QQ = nR.power(n);
//    cout << "DS" << endl;
    nP = nP * QQ;
    printf("%lld\n" , nP.a[0][en.hash]);
}
bool inmap(int x , int y){
    if (x + y == 0) return false;
    if (x + y == 4) return false;
    return 0 <= x && x < 3 && 0 <= y && y < 3;
}
int canput(int bi , int x , int y , int d){
    temp.hash = bi;
    temp.decode();
    if (!inmap(x , y) || !inmap(x + dx4[d] , y + dy4[d]) || !inmap(x + dx4[(d + 1) % 4] , y + dy4[(d + 1) % 4])) return -1;
    if (!temp.mp[x][y] || !temp.mp[x + dx4[d]][y + dy4[d]] || !temp.mp[x + dx4[(d + 1) % 4]][y + dy4[(d + 1) % 4]]) return -1;
    temp.mp[x][y] = 0;
    temp.mp[x + dx4[d]][y + dy4[d]] = 0;
    temp.mp[x + dx4[(d + 1) % 4]][y + dy4[(d + 1) % 4]] = 0;
    return temp.encode();
}
int takeOut(int bi , int x , int y , int d){
    temp.hash = bi;
    temp.decode();
    temp.mp[x][y] = 0;
    temp.mp[x + dx4[d]][y + dy4[d]] = 0;
    temp.mp[x + dx4[(d + 1) % 4]][y + dy4[(d + 1) % 4]] = 0;
    return temp.encode();
}
bool canput2(int bi , int x , int y , int d , int x1 , int y1 , int d1){
    temp.hash = bi;
    temp.decode();
    if (!inmap(x , y) || !inmap(x + dx4[d] , y + dy4[d]) || !inmap(x + dx4[(d + 1) % 4] , y + dy4[(d + 1) % 4])) return false;
    if (!temp.mp[x][y] || !temp.mp[x + dx4[d]][y + dy4[d]] || ! temp.mp[x + dx4[(d + 1) % 4]][y + dy4[(d + 1) % 4]]) return false;
    temp.mp[x][y] = 0;
    temp.mp[x + dx4[d]][y + dy4[d]] = 0;
    temp.mp[x + dx4[(d + 1) % 4]][y + dy4[(d + 1) % 4]] = 0;
    if (!inmap(x1 , y1) || !inmap(x1 + dx4[d1] , y1+ dy4[d1]) || !inmap(x1 + dx4[(d1 + 1) % 4] , y1 + dy4[(d1 + 1) % 4])) return false;
    if (!temp.mp[x1][y1] || !temp.mp[x1 + dx4[d1]][y1 + dy4[d1]] || ! temp.mp[x1 + dx4[(d1 + 1) % 4]][y1 + dy4[(d1 + 1) % 4]]) return false;
    temp.mp[x1][y1] = 0;
    temp.mp[x1 + dx4[d1]][y1 + dy4[d1]] = 0;
    temp.mp[x1 + dx4[(d1 + 1) % 4]][y1 + dy4[(d1 + 1) % 4]] = 0;
    return temp.encode() == 0;

}
void initialP(){
    P.init();
    P.Matn = 1 , P.Matm = 128;
    for (int i = 0 ; i < 128 ; ++i)
        for (int j = 0 ; j < 3 ; ++j)
            for (int k = 0 ; k < 3 ; ++k)
                for (int d = 0 ; d < 4 ; ++d){
                    int res = canput(i , j , k , d);
                    if (res == 0)
                        ++P.a[0][i];
                }
    for (int i = 0 ; i < 128 ; ++i)
        for (int j = 0 ; j < 3 ; ++j)
            for (int k = 0 ; k < 3 ; ++k)
                for (int d = 0 ; d < 4 ; ++d)
        for (int j1 = i ; j1 < 3 ; ++j1)
            for (int k1 = j ; k1 < 3 ; ++k1)
                for (int d1 = 0 ; d1 < 4 ; ++d1){
                    bool res = (canput2(i , j , k , d , j1 , k1 , d1));
                    if (res)
                        ++P.a[0][i];
                }
//    for (int i = 0 ; i < 128 ; ++i)
//    if (P.a[0][i] == 2){
//        temp.hash = i;
//        temp.decode();
//        temp.output();
//    }
}
vector< PII > memory[129][129];
bool has(int bi , int bb){
    int res = bi & bb;
    return res == bb;
}
int ok[129][129];
bool canPush(int down , int up){
//    printf("PRE : %d %d\n" , down , up);
    if(down + up == 0) {
            ok[down][up] = 1;
            return 1;
    }
//    printf("%d\n" , ok[down][up]);
    if (ok[down][up] != -1) return ok[down][up];

//    printf("NEX : %d %d\n" , down , up);
    //if (memory[down][up] != -1) return memory[down][up];
    for (int i = 0 ; i < 3 ; ++i)
    for (int j = 0 ; j < 3 ; ++j)
    for (int d = 0 ; d < 4 ; ++d){
        int res = canput(down , i , j , d);
        if (res != -1){
            int newdown = res;
            if (canPush(newdown , up)){
                memory[down][up].PB(MP(newdown , up));
                //return 1;
            }
        }
    }
    for (int i = 0 ; i < 3 ; ++i)
    for (int j = 0 ; j < 3 ; ++j)
    for (int d = 0 ; d < 4 ; ++d){
        int res = canput(up , i , j , d);
        if (res != -1){
            int newup = res;
            if (canPush(down , newup)){
                memory[down][up].PB(MP(down , newup));
//                return 1;
            }
        }
    }
    /**
            1   2
        4   8   16
        32  64
    */
    if (has(down , 3) && has(up , 1))
        if (canPush(down - 3 , up - 1)){
            memory[down][up].PB(MP(down - 3 , up - 1));}// = 1 ; return 1;}
    if (has(down , 3) && has(up , 2))
        if (canPush(down - 3 , up - 2)){
            memory[down][up].PB(MP(down - 3 , up - 2));}// = 1 ; return 1;}
    if (has(down , 12) && has(up , 4))
        if (canPush(down - 12 , up - 4)){
            memory[down][up].PB(MP(down - 12 , up - 4));}// = 1 ; return 1;}
    if (has(down , 12) && has(up , 8))
        if (canPush(down - 12 , up - 8)){
            memory[down][up].PB(MP(down - 12 , up - 8));}// = 1 ; return 1;}
    if (has(down , 24) && has(up , 8))
        if (canPush(down - 24 , up - 8)){
            memory[down][up].PB(MP(down - 24 , up - 8));}// = 1 ; return 1;}
    if (has(down , 24) && has(up , 16))
        if (canPush(down - 24 , up - 16)){
            memory[down][up].PB(MP(down - 24 , up - 16));}// = 1 ; return 1;}
    if (has(down , 96) && has(up , 32))
        if (canPush(down - 96 , up - 32)){
            memory[down][up].PB(MP(down - 96 , up - 32));}// = 1 ; return 1;}
    if (has(down , 96) && has(up , 64))
        if (canPush(down - 96 , up - 64)){
            memory[down][up].PB(MP(down - 96 , up - 24));}// = 1 ; return 1;}
    /**
            1   2
        4   8   16
        32  64
    */
    if (has(down , 36) && has(up , 4))
        if (canPush(down - 36 , up - 4)){
            memory[down][up].PB(MP(down - 36 , up - 4));}// = 1 ; return 1;}
    if (has(down , 36) && has(up , 32))
        if (canPush(down - 36 , up - 32)){
            memory[down][up].PB(MP(down - 36 , up - 32));}// = 1 ; return 1;}
    if (has(down , 9) && has(up , 1))
        if (canPush(down - 9 , up - 1)){
            memory[down][up].PB(MP(down - 9 , up - 1));}// = 1 ; return 1;}
    if (has(down , 9) && has(up , 8))
        if (canPush(down - 9 , up - 8)){
            memory[down][up].PB(MP(down - 9 , up - 8));}// = 1 ; return 1;}
    if (has(down , 72) && has(up , 8))
        if (canPush(down - 72 , up - 8)){
            memory[down][up].PB(MP(down - 72 , up - 8));}// = 1 ; return 1;}
    if (has(down , 72) && has(up , 64))
        if (canPush(down - 72 , up - 64)){
            memory[down][up].PB(MP(down - 72 , up - 64));}// = 1 ; return 1;}
    if (has(down , 18) && has(up , 2))
        if (canPush(down - 18 , up - 2)){
            memory[down][up].PB(MP(down - 18 , up - 2));}// = 1 ; return 1;}
    if (has(down , 18) && has(up , 16))
        if (canPush(down - 18 , up - 16)){
            memory[down][up].PB(MP(down - 18 , up - 16));}// = 1 ; return 1;}


    /**
            1   2
        4   8   16
        32  64
    */
    if (has(up , 3) && has(down , 1))
        if (canPush(down - 1 , up - 3 )){
            memory[down][up].PB(MP(down - 1 , up - 3));}// = 1 ; return 1;}
    if (has(up , 3) && has(down , 2))
        if (canPush(down - 2 , up - 3)){
            memory[down][up].PB(MP(down - 2 , up - 3));}// = 1 ; return 1;}
    if (has(up , 12) && has(down , 4))
        if (canPush(down - 4 , up - 12)){
            memory[down][up].PB(MP(down - 4 , up - 12));}// = 1 ; return 1;}
    if (has(up , 12) && has(down , 8))
        if (canPush(down - 8 , up - 12)){
            memory[down][up].PB(MP(down - 8 , up - 12));}// = 1 ; return 1;}
    if (has(up , 24) && has(down , 8))
        if (canPush(down - 8 , up - 24)){
            memory[down][up].PB(MP(down - 8 , up - 24));}// = 1 ; return 1;}
    if (has(up , 24) && has(down , 16))
        if (canPush(down - 16 , up - 24)){
            memory[down][up].PB(MP(down - 16 , up - 24));}// = 1 ; return 1;}
    if (has(up , 96) && has(down , 32))
        if (canPush(down - 32 , up - 96)){
            memory[down][up].PB(MP(down - 32 , up - 96));}// = 1 ; return 1;}
    if (has(up , 96) && has(down , 64))
        if (canPush(down - 64 , up - 96)){
            memory[down][up].PB(MP(down - 64 , up - 96));}// = 1 ; return 1;}
    /**
            1   2
        4   8   16
        32  64
    */
    if (has(up , 36) && has(down , 4))
        if (canPush(down - 4 , up - 36)){
            memory[down][up].PB(MP(down - 4 , up - 36));}// = 1 ; return 1;}
    if (has(up , 36) && has(down , 32))
        if (canPush(down - 32 , up - 36)){
            memory[down][up].PB(MP(down - 32 , up - 36));}// = 1 ; return 1;}
    if (has(up , 9) && has(down , 1))
        if (canPush(down - 1 , up - 9)){
            memory[down][up].PB(MP(down - 1 , up - 9));}// = 1 ; return 1;}
    if (has(up , 9) && has(down , 8))
        if (canPush(down - 8 , up - 9)){
            memory[down][up].PB(MP(down - 8 , up - 9));}// = 1 ; return 1;}
    if (has(up , 72) && has(down , 8))
        if (canPush(down - 8 , up - 72)){
            memory[down][up].PB(MP(down - 8 , up - 72));}// = 1 ; return 1;}
    if (has(up , 72) && has(down , 64))
        if (canPush(down - 64 , up - 72)){
            memory[down][up].PB(MP(down - 64 , up - 72));}// = 1 ; return 1;}
    if (has(up , 18) && has(down , 2))
        if (canPush(down - 2 , up - 18)){
            memory[down][up].PB(MP(down - 2 , up - 18));}// = 1 ; return 1;}
    if (has(up , 18) && has(down , 16))
        if (canPush(down - 16 , up - 18)){
            memory[down][up].PB(MP(down - 16 , up - 18));}// = 1 ; return 1;}
    ok[down][up] = (SZ(memory[down][up]) > 0);
    return SZ(memory[down][up]) > 0;
}
vector<PII> cmp1 , cmp2;
struct ME{
    vector<PII> del;
    ME(){
        del.clear();
    }
    void rush(){
        sort(ALL(del));
    }
    bool operator < (const ME & A) const{
        cmp1 = del;
        cmp2 = A.del;
        sort(ALL(cmp1));
        sort(ALL(cmp2));
        //if (SZ(cmp1) != SZ(cmp2)) return SZ(cmp1) < SZ(cmp2);
        for (int i = 0 ; i < min(SZ(cmp1) , SZ(cmp2)) ; ++i)
            if (cmp1[i] != cmp2[i])
                return cmp1[i] < cmp2[i];
        return false;
    }
    bool operator == (const ME & A) const{
        return (!(*this < A) && !(A < *this));
    }
};
vector<ME> mycnt;
vector<PII> :: iterator iter;
ME now;
void cnt(int down , int up){
//    printf("PRE %d %d\n" , down , up);
    if(down == 0 && up == 0){
            mycnt.PB(now);
            return;
    }
    if (ok[down][up] == 0) return;
//    printf("CNT: %d %d\n" , down , up);
//    cout << SZ(memory[down][up]) << endl;
    for(int i = 0 ; i < SZ(memory[down][up]) ;++i){
            int newdown = memory[down][up][i].fi;
            int newup = memory[down][up][i].se;
//        printf("-%d %d\n", newdown , newup);
        now.del.PB( MP(down - newdown , up - newup) );
//        printf("+ %d %d\n" , down - newdown , up - newup);
        cnt(newdown , newup);
        iter = now.del.end() - 1;
        //iter--;
//        printf("- %d %d\n" , iter->fi , iter->se);
        now.del.erase(iter);//( MP(down - newdown , up - newup) );
    }
}
void initialQ(){
    Q.init();
    Q.Matn = 128 , Q.Matm = 128;
//    canPush(3 , 127);
    mycnt.clear();
//    cnt(3 , 127);
//    sort(ALL(mycnt));
//    printf("%d\n" , unique(ALL(mycnt)) - mycnt.begin());
////    return;
//    for (int i = 0 ; i < 128 ; ++i)
//        for (int j = 0 ; j < 128; ++j)
//            canPush(i , j);
    for (int i = 0 ; i < 128 ; ++i)
        for (int j = 0 ; j < 128 ; ++j){
            if (canPush(127 - j , i)){
                mycnt.clear();
                cnt(127 - j , i);

                sort( ALL(mycnt) );
                Q.a[j][i] = unique(ALL(mycnt)) - mycnt.begin();
//
//                printf("<<<<<<<<<<<\n");
//                temp.hash = j;printf("%d:\n" , j);temp.decode();temp.output();
//                temp.hash = i;printf("%d:\n" , i);temp.decode();temp.output();
//                printf(">>>>>>>>>>>\n");
//                printf("%d\n" , SZ(mycnt));
//                for (int ds = 0 ; ds < SZ(mycnt) ; ++ds){
//                    for (int Meng = 0 ; Meng < mycnt[ds].del.size() ; ++Meng)
//                        printf("(%d,%d)  " , mycnt[ds].del[Meng].fi , mycnt[ds].del[Meng].se);
//                    cout << endl;
//                }
//                cout << endl;
//                printf("%d\n" , Q.a[j][i]);
            }
            else Q.a[j][i] = 0;
        }
}
void initialR(){
    R.init(Q);
}
void init(){
    memset(ok , -1 , sizeof(ok));
    for (int i = 0 ; i < 128 ; ++i)
        for (int j = 0 ; j < 128 ; ++j)
            memory[i][j].clear();
    initialP();
    initialQ();
    initialR();
//    cout << "GG" << endl;
}
int main(){
//    freopen("0.in" , "r" , stdin);
//    freopen("1.out" , "w" , stdout);
    init();
    solve();
}

XLK的代码：

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
#include<vector>
using namespace std;
#define fr(i,n) for(int i=0;i<n;i++)
#define fo(i,n) for(int i=1;i<=n;i++)
#define fe(i,n) for(__typeof(n.begin()) i=n.begin();i!=n.end();i++)
int a[100020],ac;
int v[100020];
long long A[130][130];
long long B[130][130];
int N=1<<7,p=1000000007;
int mk(int x,int y,int z)
{
    return 1<<x|1<<y|1<<z;
}
void pre()
{
    int x[]={0,0,1,1,1,2,2};
    int y[]={1,2,0,1,2,0,1};
    int r[3][3]={-1,0,1,2,3,4,5,6,-1};
    int u[3][3]={-1,7,8,9,10,11,12,13,-1};
    int dx[]={1,0,-1,0};
    int dy[]={0,1,0,-1};
    for(int i=0;i<7;i++)
    {
        int nx=x[i],ny=y[i];
        for(int i=0;i<4;i++)
        {
            int qx=nx+dx[i];
            int qy=ny+dy[i];
            if(qx>=0&&qy>=0&&qx<3&&qy<3&&r[qx][qy]!=-1)
            {
                a[ac++]=mk(r[nx][ny],u[nx][ny],r[qx][qy]);
                a[ac++]=mk(r[nx][ny],u[nx][ny],u[qx][qy]);
            }
            int px=nx+dx[i+1&3];
            int py=ny+dy[i+1&3];
            if(qx>=0&&qy>=0&&qx<3&&qy<3&&r[qx][qy]!=-1)
                if(px>=0&&py>=0&&px<3&&py<3&&r[px][py]!=-1)
                {
                    a[ac++]=mk(r[nx][ny],r[px][py],r[qx][qy]);
//                  a[ac++]=mk(u[nx][ny],u[px][py],u[qx][qy]);
                }                   
        }
    }
}
void mul(long long a[130][130],long long b[130][130],long long c[130][130])
{
    long long r[130][130]={};
    for(int i=0;i<N;i++)
        for(int k=0;k<N;k++)
            if(a[i][k])
                for(int j=0;j<N;j++)
                    r[i][j]=(r[i][j]+a[i][k]*b[k][j])%p;
    for(int i=0;i<N;i++)
        for(int j=0;j<N;j++)
            c[i][j]=r[i][j];
}
int main()
{
    N++; 
    pre();
//  cout << ac << endl;
    v[0]=1;
    for(int j=0;j<ac;j++)
        for(int i=0;i<1<<14;i++)
            if(v[i])
                if((i&a[j])==0)
                    v[i|a[j]]++;
    int t,n;
    for(;~scanf("%d",&n);)
    {
        memset(A,0,sizeof A);
        memset(B,0,sizeof B);
        A[0][0]=1;
        for(int i=0;i<N-1;i++)
            for(int j=0;j<N-1;j++)
                B[i][j]=v[i<<7|(127^j)];
        n++;
        int w=0;
        for(int i=0;i<7;i++)
        {
            int d;
            scanf("%1d",&d);
            w=w*2+1-d;
        }
        B[w][N-1]=1;
        B[N-1][N-1]=1;
        for(;n;n>>=1)
        {
            if(n&1)
                mul(A,B,A);
            mul(B,B,B);
        }
        if(A[0][N-1]==0)
            puts("No way");
        else
            printf("%d\n",(int)A[0][N-1]);
    }
    return 0;
}

Krites 的代码：

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <cmath>
  
using namespace std;
  
#ifndef ONLINE_JUDGE
#define DEBUG(a) cout << #a"= " << a << endl
#else
#define DEBUG(a)
#endif
typedef long long LL;
const int maxn = 1 << 7;
const int mod = (int)1e9 + 7;
 
struct Martix {
    LL C[maxn][maxn];
    Martix() { memset(C, 0, sizeof(C)); }
    void init() { memset(C, 0, sizeof(C)); }
    void initC() { for (int i = 0; i < maxn; ++i) C[i][i] = 1; }
    Martix operator*(const Martix& rhs) const {
        Martix res;
        for (int i = 0; i < maxn; ++i) {
            for (int j = 0; j < maxn; ++j) {
                for (int k = 0; k < maxn; ++k) {
                    res.C[i][j] += C[i][k] * rhs.C[k][j];
                    res.C[i][j] %= mod;
                }
            }
        }
        return res;
    }
    Martix operator+(const Martix& rhs) const {
        Martix res;
        for (int i = 0; i < maxn; ++i) {
            for (int j = 0; j < maxn; ++j) {
                res.C[i][j] = C[i][j] + rhs.C[i][j];
                if (res.C[i][j] >= mod) res.C[i][j] -= mod;
            }
        }
        return res;
    }
};
 
Martix start, inc;
int Kr[8][4] = {
    {3, 9}, {3, 6}, {6, 12}, {9, 12, 24, 72},
    {24, 48}, {48, 96}, {72, 96}
};
int Sr[] = {
    7, 11, 13, 14, 25, 56, 76, 88, 104, 112
};
void dfs(int deep, int s, int ps) {
    if (deep == 17) {
        ++start.C[ps^(maxn - 1)][s ^ (maxn - 1)]; return;
    }
    if (deep < 7) {
        int sz = (deep == 3) ? 4 : 2;
        for (int i = 0; i < sz; ++i) {
            if ((s & Kr[deep][i]) == Kr[deep][i])
                dfs(deep + 1, s ^ Kr[deep][i], ps ^ (1 << deep));
        }
        dfs(deep + 1, s, ps);
    } else {
        if ((s & Sr[deep - 7]) == Sr[deep - 7]) 
            dfs(deep + 1, s ^ Sr[deep - 7], ps);
        dfs(deep + 1, s, ps);
    }
}
 
Martix powMartix(Martix base, int N) {
    Martix res; res.initC();
    while (N) {
        if (N & 1) res = res * base;
        base = base * base;
        N >>= 1;
    }
    return res;
}
 
Martix sumMartix(int N) {
    if (N == 0) {
        return inc;
    } else if (N == 1) {
        return start;
    } else if (N % 2 == 0) {
        Martix tmp = powMartix(start, N >> 1);
        tmp = tmp + inc;
        return tmp * sumMartix(N >> 1);
    } else {
        Martix tmp = powMartix(start, N);
        return tmp + sumMartix(N - 1);
    }
}
 
void solved(int nT) {
    char s[12]; int N;
    scanf("%d", &N);
    int rs = 0;
    scanf("%s", s);
    if (s[0] == '1') rs |= 1;
    if (s[1] == '1') rs |= 2;
    scanf("%s", s);
    if (s[0] == '1') rs |= 16;
    if (s[1] == '1') rs |= 8;
    if (s[2] == '1') rs |= 4;
    scanf("%s", s);
    if (s[0] == '1') rs |= 32;
    if (s[1] == '1') rs |= 64;
    Martix result = sumMartix(N);
    LL res = result.C[maxn - 1][rs];
    if (res == 0) puts("No way");
    else printf("%lld\n", res);
}
  
int main() {
    dfs(0, maxn - 1, 0);
    inc.initC();
    int T = 1;
    //scanf("%d", &T);
    for (int nT = 1; nT <= T; ++nT) {
        solved(nT);
    }
    return 0;
}

BSBandme 的代码：

#include <iostream>
#include <fstream>
#include <string.h>
#include <cstdio>
#include <algorithm>
#include <string>
#include <vector>
#include <queue>
#include <cassert>
#include <iomanip>
#include <math.h>
#include <deque>
#include <utility>
#include <map>
#include <set>
#include <bitset>
#include <numeric>
#include <climits>
#include <cctype>
#include <cmath>
#include <cstdlib>
#include <sstream>
 
using namespace std;
 
typedef unsigned long long ull;
typedef long long ll;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;
typedef pair <double, double> pdd;
typedef vector <int> vi;
typedef vector <ll> vl;
typedef vector <double> vd;
typedef vector <string> vs;
typedef map <string, int> mpsi;
typedef map <double, int> mpdi;
typedef map <int, int> mpii;
 
const double pi = acos(0.0) * 2.0;
const double eps = 1e-12;
const int step[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
 
template <class T> inline T abs1(T a) {return a < 0 ? -a : a;}
template <class T> inline T max1(T a, T b) {return a > b ? a : b;}
template <class T> inline T min1(T a, T b) {return a < b ? a : b;}
template <class T> inline T gcd1(T a, T b) {
    if(a < b) swap(a, b);
    if(a % b == 0) return b;
    return gcd1(b, a % b);
}
template <class T> inline T lb(T num) {return num & (-num); }
inline int jud(double a, double b){
    if(abs1(a - b) < eps) return 0;
    if(a < b) return -1;
    return 1;
}
template <class t>
inline int find(int val, t *a, int na, bool f_small = 1, bool f_lb = 1){
    if(na == 1) return 0;
    int be = 0, en = na - 1;
    if(a[0] <= a[na - 1]){
        if(f_lb == 0) while(be < en){
            int mid = (be + en + 1) / 2;
            if(jud(a[mid], val) != 1) be = mid;
            else en = mid - 1;
        }else while(be < en){
            int mid = (be + en) / 2;
            if(jud(a[mid], val) != -1) en = mid;
            else be = mid + 1;
        }
        if(f_small && a[be] > val && be != 0) be--;
        if(!f_small && a[be] < val && be != na - 1) be++;
    } else {
        if(f_lb) while(be < en){
            int mid = (be + en + 1) / 2;
            if(jud(a[mid], val) != -1) be = mid;
            else en = mid - 1;
        }else while(be < en){
            int mid = (be + en) / 2;
            if(jud(a[mid], val) != 1) en = mid;
            else be = mid + 1;
        }
        if(!f_small && a[be] < val && be != 0) be--;
        if(f_small && a[be] > val && be != na - 1) be++;
    }
    return be;
}
inline int bitnum(ull nValue){
    nValue = ((0xaaaaaaaaaaaaaaaaull & nValue)>>1) + (0x5555555555555555ull & nValue);
    nValue = ((0xccccccccccccccccull & nValue)>>2) + (0x3333333333333333ull & nValue);
    nValue = ((0xf0f0f0f0f0f0f0f0ull & nValue)>>4) + (0x0f0f0f0f0f0f0f0full & nValue);
    nValue = ((0xff00ff00ff00ff00ull & nValue)>>8) + (0x00ff00ff00ff00ffull & nValue);
    nValue = ((0xffff0000ffff0000ull & nValue)>>16) + (0x0000ffff0000ffffull & nValue);
    nValue = ((0xffffffff00000000ull & nValue)>>32) + (0x00000000ffffffffull & nValue);
    return nValue;
}
long long pow(long long n, long long m, long long mod = 0){
    long long ans = 1;
    long long k = n;
    while(m){
        if(m & 1) {
            ans *= k;
            if(mod) ans %= mod;
        }
        k *= k;
        if(mod) k %= mod;
        m >>= 1;
    }
    return ans;
}
 
const int mod = 1000000007;
template <typename t> struct matrix{
    const static int maxn = 130;
    int row, col;
    t mat[maxn][maxn];
 
    matrix(int r = 0, int c = 0){
        row = r; col = c;
        for(int i = 0; i < row; i++) for(int j = 0; j < col; j++) mat[i][j] = 0;
    }
    bool danweiju(){
        if(row != col) return 0;
        for(int i = 0; i < row; i++) for(int j = 0; j < col; j++) mat[i][j] = bool (i == j);
        return 1;
    }
    matrix operator * (const matrix& b) const{
        int i, j, k;
        matrix <t> c(row, b.col);
        memset(c.mat, 0, sizeof(c.mat));
        for (i = 0; i < c.row; i++) for (k = 0; k < col; k++)
            if(mat[i][k])
                for (j = 0; j < c.col; j++){
                    c.mat[i][j] += mat[i][k] * b.mat[k][j];
                    c.mat[i][j] %= mod;
                }
        return c;
    }
    matrix operator + (const matrix& b) const{
        matrix <t> c(max1(row, b.row), max1(col, b.col));
        for(int i = 0; i < c.row; i++) for(int j = 0; j < c.col; j++){
            t a = 0; if(i < row && j < col) a = mat[i][j];
            t b1 = 0; if(i < b.row && j < b.col) b1 = b.mat[i][j];
            c.mat[i][j] = a + b1;
            c.mat[i][j] %= mod;
        }
        return c;
    }
    matrix operator - (const matrix& b) const{
        matrix <t> c(max1(row, b.row), max1(col, b.col));
        for(int i = 0; i < c.row; i++) for(int j = 0; j < c.col; j++){
            t a = 0; if(i < row && j < col) a = mat[i][j];
            t b1 = 0; if(i < b.row && j < b.col) b1 = b.mat[i][j];
            c.mat[i][j] = a - b1;
        }
        return c;
    }
    inline void operator = (const matrix & b){
        memcpy(mat, b.mat, sizeof(mat));
        col = b.col;  row = b.row;
    }
    matrix pow(int n){
        matrix <t> ans(row, col), temp = *this;
 
        ans.danweiju();
        while(n){
            if(n & 1) ans = ans * temp;
            temp = temp * temp;
            n >>= 1;
        }
        return ans;
    }
    int inv(){
        int i, j, k, is[maxn], js[maxn];
        double t1;
 
        if (row != col) return 0;
        for(k = 0; k < row; k++){
            for(t1 = 0,i = k; i < row; i++) for(j = k; j < row; j++)
                if(fabs(mat[i][j]) > t1)
                    t1=fabs(mat[is[k] = i][js[k] = j]);
            if (fabs(t1 - 0) < 1e-9) return 0;
            if (is[k] != k) for(j = 0; j < row; j++)
                t1 = mat[k][j], mat[k][j] = mat[is[k]][j], mat[is[k]][j] = t1;
            if (js[k] != k) for (i = 0; i < row; i++)
                t1 = mat[i][k], mat[i][k] = mat[i][js[k]], mat[i][js[k]] = t1;
            mat[k][k] = 1 / mat[k][k];
            for(j = 0; j < row; j++) if (j != k)
                mat[k][j] *= mat[k][k];
            for (i = 0; i < row; i++)    if (i != k)
                for (j = 0; j < row; j++) if (j != k)
                    mat[i][j] -= mat[i][k] * mat[k][j];
            for (i = 0;i < row; i++) if (i != k)
                mat[i][k] *= -mat[k][k];
        }
        for (k = row-1; k >= 0; k--){
            for (j = 0; j < row; j++) if (js[k] != k)
                    t1 = mat[k][j], mat[k][j] = mat[js[k]][j], mat[js[k]][j]=t1;
            for (i = 0; i < row; i++) if (is[k] != k)
                t1 = mat[i][k], mat[i][k] = mat[i][is[k]], mat[i][is[k]] = t1;
        }
        return 1;
    }
    double det(){
        int i, j, k, sign = 0;
        double b[maxn][maxn], ret = 1, t1;
 
        if (row != col) return 0;
        for (i = 0; i < row; i++) for (j = 0; j < col; j++)
            b[i][j] = mat[i][j];
        for (i = 0; i < row; i++){
            if (fabs(b[i][i] - 0) < 1e-9){
                for (j = i + 1; j < row; j++)
                    if (fabs(b[j][i] - 0) > 1e-9) break;
                    if (j == row) return 0;
                    for (k = i; k < row; k++)
                        t1 = b[i][k], b[i][k] = b[j][k], b[j][k] = t1;
                    sign++;
            }
            ret *= b[i][i];
            for (k = i + 1; k < row; k++) b[i][k] /= b[i][i];
            for (j = i + 1; j < row; j++) for (k = i + 1; k < row; k++)
                b[j][k] -= b[j][i] * b[i][k];
        }
        if (sign & 1) ret = -ret;
        return ret;
    }
};
 
const int trans[42][2] = {{1, 3}, {1, 9}, {2, 3}, {2, 18}, {4, 12}, {4, 36}, {8, 12}, {8, 72}, {8, 9}, {8, 24}, {16, 24}, {16, 18}, {32, 36}, {32, 96}, {64, 96}, {64, 72},
                            {3, 1}, {3, 2}, {12, 4}, {12, 8}, {24, 8}, {24, 16}, {96, 32}, {96, 64}, {36, 4}, {36, 32}, {9, 1}, {9, 8}, {72, 8}, {72, 64}, {18, 2}, {18, 16}
                            , {11, 0}, {19, 0}, {13, 0}, {44, 0}, {76, 0}, {25, 0}, {26, 0}, {88, 0}, {100, 0}, {104, 0}};
vi wh[100];
ll dp[128][128];
bool f[128][128];
pii q[1 << 15];
int lq, rq;
int ncase, n;
char str[10];
matrix <ll> m(128, 128);
 
int main(){
    for(int i = 0; i < 42; i++){
        int k = lb(trans[i][0]);
        wh[k].push_back(i);
    }
    for(int i = 0; i < 128; i++){
        memset(dp, 0, sizeof(dp));
        memset(f, 0, sizeof(f));
        dp[i][0] = 1; rq = 1; f[i][0] = 1;
        q[lq = 0] = make_pair(i, 0);
        for(; rq != lq; ){
            int wh1 = lb(q[lq].first + 1);
            for(int j = 0; j < (int)wh[wh1].size(); j++){
                if((q[lq].first & trans[wh[wh1][j]][0]) || (q[lq].second & trans[wh[wh1][j]][1])) continue;
                pii p;
                p.first = q[lq].first | trans[wh[wh1][j]][0];
                p.second = q[lq].second | trans[wh[wh1][j]][1];
                dp[p.first][p.second] += dp[q[lq].first][q[lq].second];
                if(p.first != 127 && f[p.first][p.second] == 0){
                    f[p.first][p.second] = 1;
                    q[rq++] = p;
                }
            }
            lq++;
        }
        for(int j = 0; j < 128; j++) m.mat[i][j] = dp[127][j];
    }
 
    while(scanf("%d", &n) != -1){
        for(int i = 0; i < 7; i++)
            while(str[i] != 48 && str[i] != 49)
                scanf("%c", str + i);
 
        int num = 0;
        for(int i = 0; i < 7; i++) num += (str[i] - 48) << i;
 
        m = m.pow(n - 1);
        ll ans = m.mat[0][num];
        for(int i = 0; i < 127; i++){
            for(int j = 32; j < 42; j++)
                if(((i & trans[j][0]) == 0) && ((i | trans[j][0]) == num)){
                    ans += m.mat[0][i];
                    break;
                }
        }
        if(num == 127) ans += m.mat[0][2] + m.mat[0][8] + m.mat[0][32];
        cout << num << ' ' << ans % mod << endl;
    }
 
    return 0;
}

总结：

总之我还是太弱了啊T_T。

XLK 好强啊T_T

孟竹祝你寒假快乐~love you

祝大家寒假开心，新春快乐