CodeForces 1185 G1 Playlist for Polycarp dp dfs

题意: 给出n个球, 每个球有颜色和质量, 要取出若干个球总价值为T, 且相邻的球颜色不同, 问有多少种取法. 每个球有编号(即取"红1红2"≠取"红2红1").

n<=15, 颜色=3种, T<=225, 每个球的价值<=15.

其实只要解决:

Ⅰ "一堆球有三种颜色, 有多少种排列方式使得相邻的球颜色不同"

Ⅱ dfs枚举所有取法, 得到和为T的(合法)的取法.

Ⅰ的dp思路:

我们可以模拟构造这个序列的流程:

①放一个球作为最左端 ②在它的右边放一个与其不同颜色的球. 其后就是重复②的操作. 

我们可以发现, 后面放的球只与①还剩哪些球②之前最后放的什么球有关.

那么我们可以开空间维护:①a色球还剩多少, b色球还剩多少, c色球还剩多少, d色球还剩多少 ②之前最后放的什么颜色的球.

然后dp即可.

参考:https://blog.csdn.net/Anxdada/article/details/82793576

代码:

#include<bits/stdc++.h>

using namespace std;

void debug_out() {
    cerr << '\n';
}

template<typename T, typename ...R>
void debug_out(const T &f, const R &...r) {
    cerr << f << " ";
    debug_out(r...);
}

#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_out(__VA_ARGS__);

typedef long long ll;

const ll M = 2e5 + 5;
const ll inf = 1e9 + 5;
const ll mod = 1e9 + 7;

typedef long long ll;
ll dp[22][22][22][4];


const ll maxn = 1e5 + 5;
ll Jc[maxn];

void calJc(ll mod) {
    Jc[0] = Jc[1] = 1;
    for (ll i = 2; i < maxn; i++)
        Jc[i] = Jc[i - 1] * i % mod;
}

ll comb[20][20][20];


void solve() {
    ll n, m, k;
//    while (cin >> n >> m >> k) {
    for (n = 0; n <= 15; n++) {
        for (m = 0; m <= 15; m++) {
            for (k = 0; k <= 15; k++) {
                memset(dp, 0, sizeof(dp));
                dp[n][m][k][3] = 1;
                for (ll i = n; i >= 0; i--) {
                    for (ll j = m; j >= 0; j--) {
                        for (ll p = k; p >= 0; p--) {
                            for (ll l = 0; l <= 3; l++) {
                                if (l == 3) {
                                    if (i > 0) dp[i - 1][j][p][0] = (dp[i - 1][j][p][0] + dp[i][j][p][l]) % mod;
                                    if (j > 0) dp[i][j - 1][p][1] = (+dp[i][j - 1][p][1] + dp[i][j][p][l]) % mod;
                                    if (p > 0) dp[i][j][p - 1][2] = (dp[i][j][p - 1][2] + dp[i][j][p][l]) % mod;
                                }
                                if (l == 0) {
                                    if (j > 0) dp[i][j - 1][p][1] = (dp[i][j - 1][p][1] + dp[i][j][p][l]) % mod;
                                    if (p > 0) dp[i][j][p - 1][2] = (dp[i][j][p - 1][2] + dp[i][j][p][l]) % mod;
                                }
                                if (l == 1) {
                                    if (i > 0) dp[i - 1][j][p][0] = (dp[i - 1][j][p][0] + dp[i][j][p][l]) % mod;
                                    if (p > 0) dp[i][j][p - 1][2] = (dp[i][j][p - 1][2] + dp[i][j][p][l]) % mod;
                                }
                                if (l == 2) {
                                    if (i > 0) dp[i - 1][j][p][0] = (dp[i - 1][j][p][0] + dp[i][j][p][l]) % mod;
                                    if (j > 0) dp[i][j - 1][p][1] = (dp[i][j - 1][p][1] + dp[i][j][p][l]) % mod;
                                }
                            }
                        }
                    }
                }
                ll sum = 0;
                for (ll l = 0; l <= 3; l++) {
                    sum = (sum + dp[0][0][0][l]) % mod;
                }
                comb[n][m][k] = sum * Jc[n] % mod * Jc[m] % mod * Jc[k] % mod;
            }
        }
    }
}


ll type[16];
ll v[16];
ll n, T;

ll ans = 0;

void dfs(ll pos, ll a1, ll a2, ll a3, ll sum) {
    if (sum == T) {
        ans = (ans + comb[a1][a2][a3]) % mod;
        return;
    }
    if (pos == n + 1)return;
    if (type[pos] == 1) {
        dfs(pos + 1, a1 + 1, a2, a3, sum + v[pos]);
        dfs(pos + 1, a1, a2, a3, sum);
    } else if (type[pos] == 2) {
        dfs(pos + 1, a1, a2 + 1, a3, sum + v[pos]);
        dfs(pos + 1, a1, a2, a3, sum);
    } else {
        dfs(pos + 1, a1, a2, a3 + 1, sum + v[pos]);
        dfs(pos + 1, a1, a2, a3, sum);
    }
}


int main() {
    calJc(mod);
//    solve2();
    solve();
    scanf("%d%d", &n, &T);
    for (ll i = 0; i < n; i++) {
        scanf("%d%d", &v[i], &type[i]);
    }
    dfs(0, 0, 0, 0, 0);
    printf("%d\n", ans);
    return 0;
}