13年12月CCF计算机软件能力认证

4、有趣的数

时间限制： 1.0s
内存限制： 256.0MB
问题描述：
问题描述
　　我们把一个数称为有趣的，当且仅当：
　　1. 它的数字只包含0, 1, 2, 3，且这四个数字都出现过至少一次。
　　2. 所有的0都出现在所有的1之前，而所有的2都出现在所有的3之前。
　　3. 最高位数字不为0。
　　因此，符合我们定义的最小的有趣的数是2013。除此以外，4位的有趣的数还有两个：2031和2301。
　　请计算恰好有n位的有趣的数的个数。由于答案可能非常大，只需要输出答案除以1000000007的余数。
输入格式
　　输入只有一行，包括恰好一个正整数n (4 ≤ n ≤ 1000)。
输出格式
　　输出只有一行，包括恰好n 位的整数中有趣的数的个数除以1000000007的余数。
样例输入
4
样例输出
3

思路分析：
解法一（状态机）：
由题目可知，0在1前，2在3前，可知第一位必定为2，则前n-1位全为2为状态一；
第二位可能的值为0或3，则前n-1位由2,0组成为状态二，前n-1位由2、3组成为状态三（01已确定）；
若前n-1位由0、2组成，则第n位1或3，则前n-1位由012组成为状态四，前n-1位由023组成为状态五；
前n-1位0123全部用过为状态六

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <cmath>

#define int long long

using namespace std;

typedef pair<int, int> PII;

const int N=1010,mod=1000000007;

int n;
int f[N][10];

void solve()
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        f[i][0]=1;//前i位全为2只有一种
        f[i][1]=(2*f[i-1][1]+f[i-1][0])%mod;//前i-1为全为2，第i位为0；前i-1位为02，第i位可能为0/2
        f[i][2]=(  f[i-1][2]+f[i-1][0])%mod;//前i-1为全为2，第i位为3；前i-1位为23，第i位必定为3
        f[i][3]=(2*f[i-1][3]+f[i-1][1])%mod;//前i-1为全为02，第i位为1；前i-1位为012，第i位可能为1/2
        f[i][4]=(2*f[i-1][4]+f[i-1][1]+f[i-1][2])%mod;
        f[i][5]=(2*f[i-1][5]+f[i-1][3]+f[i-1][4])%mod;
    }
    
    cout<<f[n][5];
}

signed main()
{
    int tt=1;
    // cin>>tt;
    while(tt--) solve();
}

解法二（枚举思路+组合数）：
由题目可知，可以分成01和23两个组合，设01所占的位数为k位，则2<=k<=n-2,则23占n-k位；假设先放01，由于第一位必须为2，则01一共有C[n-1][k]种，由于k-1位中0的个数不同，所以01也有k-1种放法。同理23有n-k-1种放法

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <cmath>

#define int long long

using namespace std;

typedef pair<int, int> PII;

const int N=1010,mod=1000000007;

int n;
int c[N][N];
int res=0;

void init()//初始化组合数
{
    for(int i=0;i<=1005;i++)
    {
        for(int j=0;j<=i;j++)
        {
            if(!j) c[i][j]=1;
            else
            {
                c[i][j]=(c[i-1][j]+c[i-1][j-1])%mod;
            }
        }
    }
}
void solve()
{
    cin>>n;
    init();
    for(int i=2;i<=n-2;i++)
    {
        res=(res+(c[n-1][i]*(i-1)*(n-i-1))%mod)%mod;
    }
    cout<<res;
}

signed main()
{
    int tt=1;
    // cin>>tt;
    while(tt--) solve();
}

5、I’m stuck!

时间限制： 1.0s
内存限制： 256.0MB
问题描述：
问题描述
　　给定一个R行C列的地图，地图的每一个方格可能是’#‘, ‘+’, ‘-’, ‘|’, ‘.’, ‘S’, ‘T’七个字符中的一个，分别表示如下意思：
　　‘#’: 任何时候玩家都不能移动到此方格；
　　‘+’: 当玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非’#‘方格移动一格；
　　‘-’: 当玩家到达这一方格后，下一步可以向左右两个方向相邻的一个非’#‘方格移动一格；
　　‘|’: 当玩家到达这一方格后，下一步可以向上下两个方向相邻的一个非’#‘方格移动一格；
　　‘.’: 当玩家到达这一方格后，下一步只能向下移动一格。如果下面相邻的方格为’#’，则玩家不能再移动；
　　‘S’: 玩家的初始位置，地图中只会有一个初始位置。玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非’#‘方格移动一格；
　　‘T’: 玩家的目标位置，地图中只会有一个目标位置。玩家到达这一方格后，可以选择完成任务，也可以选择不完成任务继续移动。如果继续移动下一步可以向上下左右四个方向相邻的任意一个非’#‘方格移动一格。
　　此外，玩家不能移动出地图。
　　请找出满足下面两个性质的方格个数：
　　1. 玩家可以从初始位置移动到此方格；
　　2. 玩家不可以从此方格移动到目标位置。
输入格式
　　输入的第一行包括两个整数R 和C，分别表示地图的行和列数。(1 ≤ R, C ≤ 50)。
　　接下来的R行每行都包含C个字符。它们表示地图的格子。地图上恰好有一个’S’和一个’T’。
输出格式
　　如果玩家在初始位置就已经不能到达终点了，就输出“I’m stuck!”（不含双引号）。否则的话，输出满足性质的方格的个数。
样例输入
5 5
–±+
…|#.
…|##
S-±T
####.
样例输出
2
样例说明
　　如果把满足性质的方格在地图上用’X’标记出来的话，地图如下所示：
　　--±+
　　…|#X
　　…|##
　　S-±T
　　####X
思路分析：
先从终点跑一边BFS或者DFS找到可以到达终点的点
再从起点跑一边BFS或者DFS完成题目要求

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>

using namespace std;

const int N = 55;

char g[N][N];
int n, m;
bool st1[N][N], st2[N][N];
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};  // 上左下右

bool check(int x, int y, int i)  // 判断当前点x, y是否能够沿着指示i走
{
    if(g[x][y] == 'S' || g[x][y] == 'T' || g[x][y] == '+') return true;
    if(g[x][y] == '-' && (i == 1 || i == 3)) return true;  // 如果可以往左右走(括号顺序不能忘记)
    if(g[x][y] == '|' && (i == 0 || i == 2)) return true;  // 如果可以往上下走
    if(g[x][y] == '.' && i == 2) return true;  // 如果可以向下走

    return false;
}

void bfs1(int x, int y)
{
    st1[x][y] = true;

    for(int i = 0; i < 4; i ++ )
    {
        int tx = x + dx[i], ty = y + dy[i];
        if(tx <= 0 || tx > n || ty <= 0 || ty > m) continue;
        if(g[tx][ty] == '#') continue;
        if(check(x, y, i) && !st1[tx][ty])  // 如果当前点能够满足i的要求 并且下一个点没有被遍历过
        bfs1(tx, ty);
    }
}

void bfs2(int x, int y)
{
    st2[x][y] = true;

    for(int i = 0; i < 4; i ++ )
    {
        int tx = x + dx[i], ty = y + dy[i];
        if(tx <= 0 || tx > n || ty <= 0 || ty > m) continue;
        int k = i ^ 2;  // 由于是相反操作，从终点走往其他所有点，需要将i的要求变化，原本0 变 2, 1 变 3。而^2就可以满足这个式子  
        if(g[tx][ty] == '#') continue;
        if(check(tx, ty, k) && !st2[tx][ty])  // bfs1是从a -> b，bfs2是从b -> a，判断时的条件需要按照a的条件进行反向运算。
        bfs2(tx, ty);
    }
}

int main()
{
    cin >> n >> m;

    int s_x, s_y, e_x, e_y;

    for(int i = 1; i <= n; i ++ ) 
        for(int j = 1; j <= m; j ++ )
        {    
            cin >> g[i][j];
            if(g[i][j] == 'S') s_x = i, s_y = j;
            if(g[i][j] == 'T') e_x = i, e_y = j;
        }   

    bfs1(s_x, s_y);

    if(!st1[e_x][e_y])  // 如果从起点不能走到终点
    {
        cout << "I'm stuck!" << endl;
        return 0;
    }

    bfs2(e_x, e_y);

    int cnt = 0;
    for(int i = 1; i <= n; i ++ )
        for(int j = 1; j <= m; j ++ )
            if(st1[i][j] && !st2[i][j])  // 如果能够从起点走到当前点，但是终点不能走到当前点
                cnt ++ ;

    cout << cnt << endl;

    return 0;
}