CodeForces-295-C

Greg and Friends

题意：

　　n个人过河，只有一条船，每个人体重只有两种可能，50或者100.船最大承重 k 。船必须由某一个人来划。求最小过河需要多少趟 ， 以及 在这个次数下的方案数

解决：

　　dp[ i ][ j ][ tag ];  对岸有 i 个体重50的人， j 个体重 100 的人， 此时船在 对面 （若在对面 tag = 1 ）

　　bfs去搜状态。dp记录当前方案数。 

　

#include <bits/stdc++.h>

long long comb[51][51];

int n, k, n_50, n_100;

long long dp[51][51][2];
bool vis[51][51][2];

const int MOD = 1e9+7;

struct QueNode{
    int r_50, r_100;
    bool is_r;
    int step;
    QueNode(){}
    QueNode(int _r_50, int _r_100, int _is_r, int _step)
    {
        r_50 = _r_50;
        r_100 = _r_100;
        is_r = _is_r;
        step = _step;
    }
};

void prePro()
{
    comb[0][0] = 1;
    for(int i = 1; i <= 50; ++ i){
        comb[i][0] = comb[i][i] = 1;
        for(int j = 1; j <= 50; ++ j){
            comb[i][j] = (comb[i-1][j] + comb[i-1][j-1]) % MOD;
        }
    }
}

int main()
{
    prePro();
    std::cin >> n >> k;
    memset(vis, false, sizeof vis);
    memset(dp, 0, sizeof dp);
    n_50 = n_100 = 0;
    for(int i = 1; i <= n; ++ i){
        int tmp;
        std::cin >> tmp;
        if(tmp == 50){
            n_50 ++;
        }
        else{
            n_100 ++;
        }
    }
    dp[0][0][0] = 1;
    std::queue<QueNode> que;
    que.push(QueNode(0, 0, 0, 0));
    vis[0][0][0] = true;
    long long res = 0;
    int res_step = -1;
    while(que.empty() == false){
        QueNode u = que.front(), v;
        que.pop();
        //printf("dp[%d][%d][%d] = %lld
", u.r_50, u.r_100, u.is_r, dp[u.r_50][u.r_100][u.is_r]);
        if(u.r_50 == n_50 && u.r_100 == n_100){
            res_step = u.step;
            res = dp[n_50][n_100][1];
            break;
        }
        v.step = u.step + 1;
        if(u.is_r == true){
            v.is_r = false;
            for(int i = 0; i <= u.r_50; ++ i){
                for(int j = 0; j <= u.r_100; ++ j){
                    if(i + j == 0)
                        continue;
                    if(i*50+j*100 > k)
                        continue;
                    long long tmp = dp[u.r_50][u.r_100][true]*comb[u.r_50][i]%MOD*comb[u.r_100][j]%MOD;
                    v.r_50 = u.r_50 - i;
                    v.r_100 = u.r_100 -j;
                    dp[v.r_50][v.r_100][v.is_r] += tmp;
                    dp[v.r_50][v.r_100][v.is_r] %= MOD;
                    if(vis[v.r_50][v.r_100][v.is_r] == false){
                        vis[v.r_50][v.r_100][v.is_r] = true;
                        que.push(v);
                    }
                }
            }
        }
        else{
            v.is_r = true;
            for(int i = 0; i <= n_50 - u.r_50; ++ i){
                for(int j = 0; j <= n_100 - u.r_100; ++ j){
                    if(i + j == 0)
                        continue;
                    if(i*50+j*100 > k)
                        continue;
                    long long tmp = dp[u.r_50][u.r_100][false]*comb[n_50-u.r_50][i]%MOD*comb[n_100-u.r_100][j]%MOD;
                    v.r_50 = u.r_50 + i;
                    v.r_100 = u.r_100 + j;
                    dp[v.r_50][v.r_100][v.is_r] += tmp;
                    dp[v.r_50][v.r_100][v.is_r] %= MOD;
                    if(vis[v.r_50][v.r_100][v.is_r] == false){
                        vis[v.r_50][v.r_100][v.is_r] = true;
                        que.push(v);
                    }
                }
            }

        }
    }
    std::cout << res_step << std::endl << res << std::endl;
}