cf237，D.Minesweeper 1D （小范围后效性dp）

最新推荐文章于 2014-10-14 18:26:06 发布

原创最新推荐文章于 2014-10-14 18:26:06 发布 · 899 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

动态规划

本文介绍了一种解决一维扫雷问题的动态规划方法，通过分析不同状态转移来计算可能的组合数，并提供了详细的代码实现。

题目：一维扫雷的情景，输入一行串，包含0,1,2，*，？

0，1， 2,表示周围的雷的个数，*表示雷，？表示未定。问共有多少中合理组合.

线性dp：

dp[n][i]表示的是长度为n的串的状态

i= 0时表示，其后面不加*的组合数；i= 1时，其后面加*的组合数；i= 2表示，当前的位置为*的组合数

注意初始化和最后的取解

Codefoeces 404D Minesweeper 1D "小范围后效性"dp写的不错

//#pragma warning (disable: 4786)
//#pragma comment (linker, "/STACK:16777216")
//HEAD
#include <cstdio>
#include <ctime>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <string>
#include <set>
#include <stack>
#include <map>
#include <cmath>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
//LOOP
#define FE(i, a, b) for(int i = (a); i <= (b); ++i)
#define FD(i, b, a) for(int i = (b); i>= (a); --i)
#define REP(i, N) for(int i = 0; i < (N); ++i)
#define CLR(A,value) memset(A,value,sizeof(A))
#define CPY(a, b) memcpy(a, b, sizeof(a))
#define FC(it, c) for(__typeof((c).begin()) it = (c).begin(); it != (c).end(); it++)
//INPUT
#define RI(n) scanf("%d", &n)
#define RII(n, m) scanf("%d%d", &n, &m)
#define RIII(n, m, k) scanf("%d%d%d", &n, &m, &k)
#define RS(s) scanf("%s", s)
//OUTPUT
#define WI(n) printf("%d\n", n)
#define WS(s) printf("%s\n", s)

typedef long long LL;
const int INF = 1000000007;
const double eps = 1e-10;
const int maxn = 1100010;
const int MOD = 1000000007;

int n, k;
int dp[maxn][3];
int main ()
{
    char s[maxn];
    scanf("%s", s);
    n = strlen(s);
    if (s[0] == '1') dp[1][1] = 1;
    else if (s[0] == '0') dp[1][0] = 1;
    else if (s[0] == '*') dp[1][2] = 1;
    else if (s[0] == '?')
    {
        dp[1][1] = 1;
        dp[1][0] = 1;
        dp[1][2] = 1;
    }
    for (int i = 1; i < n; i++)
    {
        if (s[i] == '?' || s[i] == '0')
        {
            dp[i + 1][0] += dp[i][0];
            dp[i + 1][0] %= MOD;
        }
        if (s[i] == '?' || s[i] == '1')
        {
            dp[i + 1][0] += dp[i][2];
            dp[i + 1][0] %= MOD;
            dp[i + 1][1] += dp[i][0];
            dp[i + 1][1] %= MOD;
        }
        if (s[i] == '?' || s[i] == '2')
        {
            dp[i + 1][1] += dp[i][2];
            dp[i + 1][1] %= MOD;
        }
        if (s[i] == '?' || s[i] == '*')
        {
            dp[i + 1][2] += dp[i][1] + dp[i][2];
            dp[i + 1][2] %= MOD;
        }
    }
    cout << (dp[n][0] + dp[n][2]) % MOD << endl;
    return 0;
}

小范围后效性dp，参考上文写的。感觉记录后面的状态和不记录后面的状态的写法差不多，关键还是分析清楚

//#pragma warning (disable: 4786)
//#pragma comment (linker, "/STACK:16777216")
//HEAD
#include <cstdio>
#include <ctime>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <string>
#include <set>
#include <stack>
#include <map>
#include <cmath>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
//LOOP
#define FE(i, a, b) for(int i = (a); i <= (b); ++i)
#define FD(i, b, a) for(int i = (b); i>= (a); --i)
#define REP(i, N) for(int i = 0; i < (N); ++i)
#define CLR(A,value) memset(A,value,sizeof(A))
#define CPY(a, b) memcpy(a, b, sizeof(a))
#define FC(it, c) for(__typeof((c).begin()) it = (c).begin(); it != (c).end(); it++)
//INPUT
#define RI(n) scanf("%d", &n)
#define RII(n, m) scanf("%d%d", &n, &m)
#define RIII(n, m, k) scanf("%d%d%d", &n, &m, &k)
#define RS(s) scanf("%s", s)
//OUTPUT
#define WI(n) printf("%d\n", n)
#define WS(s) printf("%s\n", s)

typedef long long LL;
const int INF = 1000000007;
const double eps = 1e-10;
const int MAXN = 1000010;
const int MOD = 1000000007;

int dp[1000100][5];
char s[1000100];
/***
0:0

1:当前为1，前一个为*
2:当前为1，后一个为*（前一个不为*）

3:2
4:*
*/
int main ()
{
    scanf("%s", s);
    int n = strlen(s);
    if (s[0] == '2')
    {
        printf("0\n");
        return 0;
    }
    if (s[0] == '0')
        dp[1][0] = 1;
    else if (s[0] == '1')
        dp[1][2] = 1;
    else if (s[0] == '*')
        dp[1][4] = 1;
    else if (s[0] = '?')
    {
        dp[1][0] = dp[1][2] = dp[1][4] = 1;
    }
    for (int i = 1; i < n; i++)
    {
        char c = s[i];
        if (c == '1')
        {
            dp[i + 1][2] += (dp[i][0] + dp[i][1]) % MOD;
            dp[i + 1][2] %= MOD;
            dp[i + 1][1] += dp[i][4];
            dp[i + 1][1] %= MOD;
        }
        else if (c == '0')
        {
            dp[i + 1][0] += (dp[i][0] + dp[i][1]) % MOD;
            dp[i + 1][0] %= MOD;
        }
        else if (c == '2')
        {
            dp[i + 1][3] += dp[i][4];
            dp[i + 1][3] %= MOD;
        }
        else if (c == '*')
        {
            dp[i + 1][4] += ((dp[i][3] + dp[i][2]) % MOD + dp[i][4]) % MOD;
            dp[i + 1][4] %= MOD;
        }
        else
        {
            dp[i + 1][2] += (dp[i][0] + dp[i][1]) % MOD;
            dp[i + 1][2] %= MOD;
            dp[i + 1][1] += dp[i][4];
            dp[i + 1][1] %= MOD;
            dp[i + 1][0] += (dp[i][0] + dp[i][1]) % MOD;
            dp[i + 1][0] %= MOD;
            dp[i + 1][3] += dp[i][4];
            dp[i + 1][3] %= MOD;
            dp[i + 1][4] += ((dp[i][3] + dp[i][2]) % MOD + dp[i][4]) % MOD;
            dp[i + 1][4] %= MOD;
        }
    }
    int ans = dp[n][0];
    ans += (dp[n][1] + dp[n][4]) % MOD;
    ans %= MOD;
    cout << ans << endl;

    return 0;
}

标签

#cf #dp