BZOJ 4806

4806: 炮

Time Limit: 10 Sec  Memory Limit: 128 MB
Submit: 103  Solved: 72
[Submit][Status][Discuss]

Description

众所周知，双炮叠叠将是中国象棋中很厉害的一招必杀技。炮吃子时必须隔一个棋子跳吃，即俗称"炮打隔子"。 

炮跟炮显然不能在一起打起来，于是rly一天借来了许多许多的炮在棋盘上摆了起来……他想知道，在N×M的矩形

方格中摆若干炮（可以不摆）使其互不吃到的情况下方案数有几种。

棋子都是相同的。

Input

一行，两个正整数N和M。

N<=100,M<=100

Output

一行，输出方案数mod 999983。

Sample Input

1 3

Sample Output

7

HINT

 

Source

By FancyCoder

[Submit][Status][Discuss]

#include<cstdio>
#define N 105
#define P 999983
int n,m;long long f[N][N][N],ans;
inline long long C(int a,int b){
    return b==1?a:(1LL*a*(a-1)/2)%P;
}
main(){
    scanf("%d%d",&n,&m),f[0][m][0]=1;
    for(int i=0;i<n;++i)
        for(int j=0;j<=m;++j)
            for(int k=0;k<=m;++k)
                if(f[i][j][k]){
                    (f[i+1][j][k]+=f[i][j][k])%=P;
                    if(j>0)(f[i+1][j-1][k+1]+=f[i][j][k]*C(j,1))%=P;
                    if(j>1)(f[i+1][j-2][k+2]+=f[i][j][k]*C(j,2))%=P;
                    if(j>0)(f[i+1][j-1][k]+=f[i][j][k]*C(j,1)%P*C(k,1))%=P;
                    if(k>0)(f[i+1][j][k-1]+=f[i][j][k]*C(k,1))%=P;
                    if(k>1)(f[i+1][j][k-2]+=f[i][j][k]*C(k,2))%=P;
                }
    for(int i=0;i<=m;++i)
        for(int j=0;j<=m;++j)
            ans=(ans+f[n][i][j])%P;
    printf("%lld
",ans);
}

4807: 車

Time Limit: 10 Sec  Memory Limit: 128 MB
Submit: 126  Solved: 45
[Submit][Status][Discuss]

Description

众所周知，車是中国象棋中最厉害的一子之一，它能吃到同一行或同一列中的其他棋子。車跟車显然不能在一起打

起来，于是rly一天又借来了许多许多的車在棋盘上摆了起来……他想知道，在N×M的矩形方格中摆最多个数的車

使其互不吃到的情况下方案数有几种。但是，由于上次摆炮摆得实在太累，他为了偷懒，打算增加一个条件：对于

任何一个車A，如果有其他一个車B在它的上面（車B行号小于車A），那么車A必须在車B的右边（車A列号大于車B）

。

棋子都是相同的。

Input

一行，两个正整数N和M。

N<=1000000，M<=1000000

Output

一行，输出方案数的末尾50位（不足则直接输出）。

 

Sample Input

2 2

Sample Output

1

HINT

 

Source

By FancyCoder

[Submit][Status][Discuss]

#include<cstdio>
#define N 1000005
int n,m,t,pri[N],que[N],cnt[N],ans[64],tot=1,mor;
void calc(int lim,int flg){
    for(int i=2;i<=lim;++i)
        for(int num=i;num!=1;)
            cnt[pri[num]]+=flg,num/=pri[num];
}
main(){
    scanf("%d%d",&n,&m);
    if(n<m)n^=m^=n^=m;
    for(int i=2;i<=n;++i){
        if(!pri[i])que[++t]=pri[i]=i;
        for(int j=1;j<=t&&i*que[j]<=n;++j){
            pri[que[j]*i]=que[j];
            if(!(i%que[j]))break;
        }
    }
    ans[1]=1;
    calc(n,+1);
    calc(m,-1);
    calc(n-m,-1);
    for(int i=1;i<=t;++i)
        for(int j=1;j<=cnt[que[i]];++j){tot+=7;
            for(int k=1;k<=tot;++k)ans[k]*=que[i];
            for(int k=1;k<=tot;++k)ans[k+1]+=ans[k]/10,ans[k]%=10;
            while(tot&&!ans[tot])--tot;if(tot>50)tot=50;
        }
    while(tot&&!ans[tot])--tot;
    for(int i=tot;i;--i)putchar('0'+ans[i]);
}

4808: 马

Time Limit: 10 Sec  Memory Limit: 128 MB
Submit: 106  Solved: 43
[Submit][Status][Discuss]

Description

众所周知，马后炮是中国象棋中很厉害的一招必杀技。"马走日字"。本来，如果在要去的方向有别的棋子挡住（俗

称"蹩马腿"），则不允许走过去。为了简化问题，我们不考虑这一点。马跟马显然不能在一起打起来，于是rly在

一天再次借来了许多许多的马在棋盘上摆了起来……但这次，他实在没兴趣算方案数了，所以他只想知道在N×M的

矩形方格中摆马使其互不吃到的情况下的最多个数。但是，有一个很不幸的消息，rly由于玩得太Happy，质量本来

就不好的棋盘被rly弄坏了，不过幸好只是破了其中的一些格子（即不能再放子了），问题还是可以继续解决的。

Input

一行，两个正整数N和M。

接下来N行，每行M个数，要么为0，表示没坏，要么为1，表示坏了。

N<=200,M<=200

Output

一行，输出最多的个数。

Sample Input

2 3
0 1 0
0 1 0

Sample Output

2

HINT

 

Source

By FancyCoder

[Submit][Status][Discuss]

#include <cstdio>
 
template <class T>
inline T min(const T &a, const T &b)
{
    return a < b ? a : b;
}
 
inline int nextInt(void)
{
    int r = 0;
    int f = 0;
    int c = getchar();
     
    for (; c < 48; c = getchar())
        if (c == '-')f = 1;
     
    for (; c > 47; c = getchar())
        r = r * 10 + c - 48;
     
    return f ? -r : r;
}
 
const int mxn = 40005;
const int mxm = 2000005;
const int inf = 1000000007;
 
int s;
int t;
int tt;
int hd[mxn];
int nt[mxm];
int to[mxm];
int fl[mxm];
 
inline void add(int x, int y)
{
    nt[tt] = hd[x], to[tt] = y, fl[tt] = 1, hd[x] = tt++;
    nt[tt] = hd[y], to[tt] = x, fl[tt] = 0, hd[y] = tt++;
}
 
int dep[mxn];
int que[mxn];
int cur[mxn];
 
inline bool bfs(void)
{
    for (int i = s; i <= t; ++i)
        dep[i] = 0;
     
    int l = 0, r = 1;
    dep[s] = 1;
    que[0] = s;
     
    while (l != r)
    {
        int u = que[l++], v;
         
        for (int i = hd[u]; ~i; i = nt[i])
            if (v = to[i], !dep[v] && fl[i])
                dep[que[r++] = v] = dep[u] + 1;
    }
     
    return dep[t];
}
 
int dfs(int u, int f)
{
    if (!f || u == t)
        return f;
     
    int used = 0, flow, v;
     
    for (int &i = cur[u]; ~i; i = nt[i])
        if (v = to[i], fl[i] && dep[v] == dep[u] + 1)
        {
            flow = dfs(v, min(f - used, fl[i]));
             
            used += flow;
            fl[i] -= flow;
            fl[i^1] += flow;
             
            if (used == f)
                return used;
        }
     
    if (!used)
        dep[u] = 0;
     
    return used;
}
 
inline int flow(void)
{
    int ret = 0, tmp;
     
    while (bfs())
    {
        for (int i = s; i <= t; ++i)
            cur[i] = hd[i];
         
        while (tmp = dfs(s, inf))
            ret += tmp;
    }
     
    return ret;
}
 
int n, m, id[205][205];
 
const int mov[8][2] =
{
    {+2, +1},
    {+2, -1},
    {-2, +1},
    {-2, -1},
    {+1, +2},
    {+1, -2},
    {-1, +2},
    {-1, -2}
};
 
signed main(void)
{
    n = nextInt();
    m = nextInt();
     
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= m; ++j)
            if (!nextInt())id[i][j] = ++t;
     
    ++t;
     
    for (int i = s; i <= t; ++i)
        hd[i] = -1;
     
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= m; ++j)
            if (id[i][j])
            {
                if ((i ^ j) & 1)
                    add(s, id[i][j]);
                else
                    add(id[i][j], t);
            }
     
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= m; ++j)
            if (((i ^ j) & 1) && id[i][j])
                for (int k = 0; k < 8; ++k)
                {
                    int x = i + mov[k][0];
                    int y = j + mov[k][1];
                     
                    if (x < 1 || x > n)continue;
                    if (y < 1 || y > m)continue;
                     
                    if (!id[x][y])continue;
                     
                    add(id[i][j], id[x][y]);
                }
     
    printf("%d
", t - 1 - flow());
}

4809: 皇后

Time Limit: 10 Sec  Memory Limit: 128 MB
Submit: 123  Solved: 62
[Submit][Status][Discuss]

Description

众所不知，rly现在不会玩国际象棋。但是，作为一个OIer，rly当然做过八皇后问题。这里再啰嗦几句，皇后可以攻击到同行同列同对角线，在n*n的方格中摆n个皇后使其互不攻击到，求不同的解的数量，这就是经典的n皇后问题。现在问题推广到n皇后问题，这个问题对于你而言实在是小菜一叠。但因为上一次rly把棋盘弄破了，又拿不出新的，所以rly打算难一点点，问题就是破棋盘上的n皇后问题。他想知道……（你们懂的）。

棋子都是相同的。

Input

一行，一个正整数N。

接下来N行，每行N个数，要么为0，表示没坏，要么1，表示坏了。

N<=16

Output

一行，输出不同的解的数量。

Sample Input

4
1 0 1 1
1 1 1 0
0 1 1 1
1 1 0 1

Sample Output

1

HINT

 

Source

By FancyCoder

[Submit][Status][Discuss]

#include <cstdio>

inline int nextInt(void)
{
    int r = 0;
    int c = getchar();
    
    for (; c < 48; c = getchar());
    for (; c > 47; c = getchar())
        r = r * 10 + c - 48;
    
    return r;
}

const int mxn = 20;

typedef unsigned long long lnt;

int n, ans, map[mxn][mxn];

void search(int x, lnt a, lnt b, lnt c)
{
    if (x == n)++ans;
    else
    {
        lnt d = a | b | c;
        
        for (register int y = 0; y < n; ++y)
            if (!map[x][y] && !((d >> y) & 1))
                search(x + 1,
                    (a | (1ULL << y)),
                    (b | (1ULL << y)) >> 1,
                    (c | (1ULL << y)) << 1);
    }
}

signed main(void)
{
    n = nextInt();
    
    for (int i = 0; i < n; ++i)
        for (int j = 0; j < n; ++j)
            map[i][j] = nextInt();
    
    search(0, 0, 0, 0);
    
    printf("%d
", ans);
}

@Author: YouSiki