ccf-csp 2013冬季真题题解

---

1. 出现次数最多的数
   问题描述
   　　给定n个正整数，找出它们中出现次数最多的数。如果这样的数有多个，请输出其中最小的一个。
   输入格式
   　　输入的第一行只有一个正整数n(1 ≤ n ≤ 1000)，表示数字的个数。
   　　输入的第二行有n个整数s1, s2, …, sn (1 ≤ si ≤ 10000, 1 ≤ i ≤ n)。相邻的数用空格分隔。
   输出格式
   　　输出这n个次数中出现次数最多的数。如果这样的数有多个，输出其中最小的一个。
   样例输入
   6
   10 1 10 20 30 20
   样例输出
   10
   题解：
     简单模拟。

代码：

#include 

using namespace std;
const int MAXN = 10010;
int arr[MAXN];

int main(){
    int n, a, ans;

    cin >> n;
    while(n --){
        cin >> a;
        arr[a] ++;
        if(arr[a] > arr[ans] || (arr[a] == arr[ans] && a < ans))
            ans = a;
    }
    cout << ans << endl;
    return 0;
}

---

2. ISBN号码
   问题描述
   　　每一本正式出版的图书都有一个ISBN号码与之对应，ISBN码包括9位数字、1位识别码和3位分隔符，其规定格式如“x-xxx-xxxxx-x”，其中符号“-”是分隔符（键盘上的减号），最后一位是识别码，例如0-670-82162-4就是一个标准的ISBN码。ISBN码的首位数字表示书籍的出版语言，例如0代表英语；第一个分隔符“-”之后的三位数字代表出版社，例如670代表维京出版社；第二个分隔之后的五位数字代表该书在出版社的编号；最后一位为识别码。
   　　识别码的计算方法如下：
   　　首位数字乘以1加上次位数字乘以2……以此类推，用所得的结果mod 11，所得的余数即为识别码，如果余数为10，则识别码为大写字母X。例如ISBN号码0-670-82162-4中的识别码4是这样得到的：对067082162这9个数字，从左至右，分别乘以1，2，…，9，再求和，即0×1+6×2+……+2×9=158，然后取158 mod 11的结果4作为识别码。
   　　编写程序判断输入的ISBN号码中识别码是否正确，如果正确，则仅输出“Right”；如果错误，则输出是正确的ISBN号码。
   输入格式
   　　输入只有一行，是一个字符序列，表示一本书的ISBN号码（保证输入符合ISBN号码的格式要求）。
   输出格式
   　　输出一行，假如输入的ISBN号码的识别码正确，那么输出“Right”，否则，按照规定的格式，输出正确的ISBN号码（包括分隔符“-”）。
   样例输入
   0-670-82162-4
   样例输出
   Right
   样例输入
   0-670-82162-0
   样例输出
   0-670-82162-4
   题解：
     简单模拟。
   代码：

#include 
#include 

using namespace std;

int main(){
    string s;
    int cnt = 1, sum = 0;

    cin >> s;
    for(int i = 0; i < s.length() - 1; i ++){
        if(s[i] == '-')
            continue;
        sum += cnt * (s[i] - '0');
        ++ cnt;
    }
    sum = sum % 11;

    if(s[s.length() - 1] == 'X' && sum == 10)
        cout << "Right" ;
    else if(s[s.length() - 1] != 'X' && s[s.length() - 1] == sum + '0')
        cout << "Right";
    else{
        if(sum == 10)
            s[s.length() - 1] = 'X';
        else
            s[s.length() - 1] = sum + '0';
        cout << s;
    }
    return 0;
}

---

3. 最大的矩形
   问题描述
   　　在横轴上放了n个相邻的矩形，每个矩形的宽度是1，而第i（1 ≤ i ≤ n）个矩形的高度是hi。这n个矩形构成了一个直方图。例如，下图中六个矩形的高度就分别是3, 1, 6, 5, 2, 3。
   
   　　请找出能放在给定直方图里面积最大的矩形，它的边要与坐标轴平行。对于上面给出的例子，最大矩形如下图所示的阴影部分，面积是10。
   
   输入格式
   　　第一行包含一个整数n，即矩形的数量(1 ≤ n ≤ 1000)。
   　　第二行包含n 个整数h1, h2, … , hn，相邻的数之间由空格分隔。(1 ≤ hi ≤ 10000)。hi是第i个矩形的高度。
   输出格式
   　　输出一行，包含一个整数，即给定直方图内的最大矩形的面积。
   样例输入
   6
   3 1 6 5 2 3
   样例输出
   10
   题解：
     数据范围较小，只有1000，可以使用O(n²)的解法，暴力枚举左右端点，移动过程中维护最大值即可。
     有O(n)的巧妙解法，使用单调栈，见柱状图中最大的矩形

代码：

#include 
#include 

using namespace std;
const int MAXN = 1010;
int arr[MAXN];

int main(){
    int n, ans = 0;
    
    cin >> n;
    for(int i = 0; i < n; i ++) 
        cin >> arr[i];
    
    for(int i = 0; i < n; i ++){
        int t = arr[i];
        for(int j = i; j < n; j ++){
            t = min(t, arr[j]);
            ans = max(ans, (j - i + 1) * t);
        }
    }
    cout << ans << endl;
    return 0;
}

---

4. 有趣的数
   问题描述
   　　我们把一个数称为有趣的，当且仅当：
   　　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
   题解：
     首先从n个数里面确定i个01，就是Cⁱ_n，然后需要确定这i个数字里面有几个0几个1，注意至少有一个0和1，所以这i个01中，01的方案有 i - 1种，同理(n - i)个23里也有(n - i - 1)种方案，所以答案为 for i = 2 : n { Cⁱ_n * (i - 1) * (n - i - 1) } ，同时还需要注意首位不能放0，所以Cⁱ_n 为 Cⁱ_{n - 1} 。

代码：

#include 

using namespace std;
const int MAXN = 1010, MOD = 1e9 + 7;
int arr[MAXN][MAXN];

int main(){
	//预先处理组合数
    for(int i = 0; i < MAXN; i ++)
        for(int j = 0; j <= i; j ++)
            if(j)   arr[i][j] = (arr[i - 1][j] + arr[i - 1][j - 1]) % MOD;
            else    arr[i][j] = 1;

    int n, ans = 0;

    cin >> n;
    //枚举 01个数
    for(int i = 2; i <= n - 2; i ++){
        ans = (ans + (long long)arr[n - 1][i] * (i - 1) * (n - i - 1)) % MOD;
    }
    cout << ans;
    return 0;
}

---

5. I’m stuck!
   问题描述
   　　给定一个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，第一次从起点bfs，得到从起点能够走到的方格，标记为1，第二次从终点bfs，得到从终点能够走到的方格，记位2，最后遍历一下总的矩阵，那些标记1没有标记2的方格就是答案。两次bfs一个不同点就是，反向bfs的时候，如果当前位置想往上走一格，那么需要判断上一个格子能否往下走一格，因为当前格子是从上一个格子走过来的。细节见代码…

代码：

#include 

using namespace std;

const int MAXN = 60;
//记录两次bfs
bool vis1[MAXN][MAXN], vis2[MAXN][MAXN];
char g[MAXN][MAXN];
int fx[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
int n, m;

//判断r c这个格子能够向 i 方向走
bool check(int r, int c, int i){
    if(g[r][c] == '+')
        return true;
    else if(g[r][c] == 'S' || g[r][c] == 'T')
        return true;
    else if(g[r][c] == '-' && i < 2)
        return true;
    else if(g[r][c] == '|' && i > 1)
        return true;
    else if(g[r][c] == '.' && i == 2)
        return true;
    else
        return false;
}
//正向bfs
void dfs1(int r, int c){
    vis1[r][c] = true;
    for(int i = 0; i < 4; i ++){
        int a = r + fx[i][0];
        int b = c + fx[i][1];
        if(a >= 0 && a < n && b >= 0 && b < m && g[a][b] != '#' && !vis1[a][b] && check(r, c, i))
            dfs1(a, b);
    }
}
//反向bfs
void dfs2(int r, int c){
    vis2[r][c] = true;
    for(int i = 0; i < 4; i ++){
        int a = r + fx[i][0];
        int b = c + fx[i][1];
        //留意 i ^ 1就得到了相反的方向 我们一开始定义的方向 0右 1左 2下 3上
        if(a >= 0 && a < n && b >= 0 && b < m && g[a][b] != '#' && !vis2[a][b] && check(a, b, i ^ 1))
            dfs2(a, b);
    }
}

int main(){
    int r1, c1, r2, c2;
    cin >> n >> m;    

    for(int i = 0; i < n; i ++){
        for(int j = 0; j < m; j ++){
            cin >> g[i][j];
            if(g[i][j] == 'S')
                r1 = i, c1 = j;
            if(g[i][j] == 'T')
                r2 = i, c2 = j;
        }
    }

    dfs1(r1, c1);
    //正向bfs不能够到达终点
    if(!vis1[r2][c2])
        cout << "I'm stuck!" ;
    else{
    	//反向bfs
        dfs2(r2, c2);

        int ans = 0;
        //计算满足要求的方格数量
        for(int i = 0; i < n; i ++)
            for(int j = 0; j < m; j ++)
                if(vis1[i][j] && !vis2[i][j])
                    ++ ans;
        cout << ans << endl;
    }

    return 0;
}