【递推型 dp】A020_LQ_垒骰子（暴搜 / dp-＞滚动数组优化内存）

赌圣atm晚年迷恋上了垒骰子，就是把骰子一个垒在另一个上边，不能歪歪扭扭，要垒成方柱体。

经过长期观察，atm 发现了稳定骰子的奥秘：有些数字的面贴着会互相排斥！
我们先来规范一下骰子：1 的对面是 4，2 的对面是 5，3 的对面是 6。

假设有 m 组互斥现象，每组中的那两个数字的面紧贴在一起，骰子就不能稳定的垒起来。

atm想计算一下有多少种不同的可能的垒骰子方式。

两种垒骰子方式相同，当且仅当这两种方式中对应高度的骰子的对应数字的朝向都相同。由于方案数可能过多，请输出模 10^9 + 7 的结果。

不要小看了 atm 的骰子数量哦～

输入格式
第一行两个整数 n m
n表示骰子数目
接下来 m 行，每行两个整数 a b ，表示 a 和 b 数字不能紧贴在一起。

输出格式
一行一个数，表示答案模 10^9 + 7 的结果。

样例输入
2 1
1 2
样例输出
544

数据范围
对于 30% 的数据：n <= 5
对于 60% 的数据：n <= 100
对于 100% 的数据：0 < n <= 10^9, m <= 36

方法一：暴搜

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod=1e9+7;
const int N=7;
int n, m, ans, mt[N][N], mp[N];

int dfs(int i, int up) {
    if (i==n) return 4; //最后一个骰子可以旋转
    int t=0;
    for (int j=1; j<N; j++) if (!mt[up][j]) {
        t=(t+dfs(i+1, mp[j]))%mod;
    }
    return t;
}
int main() {
    std::ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    cin>>n>>m;
    for (int i=0; i<m; i++) {
        int a,b; cin>>a>>b;
        mt[a][b]=mt[b][a]=1;
    }
    mp[1]=4, mp[2]=5, mp[3]=6;
    mp[4]=1, mp[5]=2, mp[6]=3;
    for (int i=1; i<N; i++) {   //以每一个面作为上面
        ans=(ans+4*dfs(1, i))%mod; //第一个骰子旋转
    }
    cout << ans;
    return 0;
}

方法二：dp（超时）

参考别人的滚动 dp 的思路：由于上一层之和下一层有关，最终答案是只是对最上面一层的结果进行统计，可以利用滚动数组

• 定义状态：
  • f[i][j] 表示第 i 层且顶面点数为 j 的方案数
• 思考初始化：
  • f[0][1…6]=1
• 思考状态转移方程：
  • f[x][j] += f[x^1][k]
• 思考输出：sum(f[1][1…7])

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod=1e9+7, N=7;
ll n, m, ans, mt[N+5][N+5], mp[N+5];

int main() {
    std::ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    cin>>n>>m;
    for (int i=0; i<m; i++) {
        int a,b; cin>>a>>b;
        mt[a][b]=mt[b][a]=1;
    }
    mp[1]=4, mp[2]=5, mp[3]=6;
    mp[4]=1, mp[5]=2, mp[6]=3;

    ll f[n+5][N+5]; memset(f, 0, sizeof f);
    for (int j=1; j<N; j++) f[0][j]=1;
    
    ll x=1, y=4;
    for (int i=1; i<n; i++) {
        for (int j=1; j<7; j++) {
            f[x][j]=0;
            for (int k=1; k<7; k++) if (!mt[k][mp[j]]) {
                f[i][j]=(f[i][j]+f[i-1][k])%mod;
            }
        }
        y=(y*4)%mod;
    }
    ll ans=0;
    for (int j=1; j<7; j++) ans=(ans+f[n-1][j])%mod;
    ans = (ans*y)%mod;
    cout << ans;
    return 0;
}

滚动数组优化内存…

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod=1e9+7, N=7;
ll n, m, ans, mt[N+5][N+5], mp[N+5];

int main() {
    std::ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    cin>>n>>m;
    for (int i=0; i<m; i++) {
        int a,b; cin>>a>>b;
        mt[a][b]=mt[b][a]=1;
    }
    mp[1]=4, mp[2]=5, mp[3]=6;
    mp[4]=1, mp[5]=2, mp[6]=3;

    ll f[2][N+5]; memset(f, 0, sizeof f);
    for (int j=1; j<7; j++) f[0][j]=4;
    
    ll x=1, y=1;
    for (ll i=1; i<n; i++) {
        for (int j=1; j<7; j++) {
            f[x][j]=0;
            for (int k=1; k<7; k++) if (!mt[k][mp[j]]) {
                f[x][j]=(f[x][j]+f[x^1][k])%mod;
            }
        }
        x^=1, y=(y*4)%mod;
    }
    ll ans=0;
    for (int j=1; j<7; j++) ans=(ans+f[x^1][j])%mod;
    ans = (ans*y)%mod;
    cout << ans;
    return 0;
}

复杂度分析

• Time：$O(n)$，
• Space：$O(n)$，