ACM解题总结——HihoCoder1153

题目来源：

        HihoCoder 1153
题目要求：
    以下是常见的手机数字键盘的排列方式：
                    1 2 3 
                    4 5 6
                    7 8 9
                      0
    开始状态下，你的手指的在按键1的位置。可以执行的操作有：按下手指所在位置的按键，或者将手指向下移动到下一个按键，或者将手指一定到右边的下一个按键。而向左和向上移动是不允许的。
    要求给定一个数字K，在不限制操作次数的情况下，求出在这样的操作方式下，可以输出的不大于K的最大数字。

解答：
    这个题目比较简单。数据量比较小，所以用最朴素的深度优先搜索算法就可以得到结果。
    首先需要了解的是，当手指处于某一个位置时，它还可以移动到那些位置。这里可以利用可达矩阵得到这些信息。首先将题目中的键盘转化成一个有向图，如下：

     


    然后，就可以得到可达矩阵，如果从数字i可以到达数字j，那么矩阵中第i行，第j列数字为1，否则为0，可达矩阵(记为V)如下， 其中行、列的编号都是从0开始的：

1 0 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1 1
1 0 1 1 0 1 1 0 1 1
0 0 0 1 0 0 1 0 0 1
1 0 0 0 1 1 1 1 1 1
1 0 0 0 0 1 1 0 1 1
0 0 0 0 0 0 1 0 0 1
1 0 0 0 0 0 0 1 1 1
1 0 0 0 0 0 0 0 1 1
0 0 0 0 0 0 0 0 0 1
    然后，就可以进行搜索求解了。保证得到的结果最大，那么就要尽可能地使结果中的各个数位的数字和K接近。搜索从最高位开始。起始位置是1，由于1可以到达所有数字，因此结果的最高位数字就是K的最高位数字。

    在后续的搜索中，则需要枚举，设上一轮的搜索结果是s, 那么在本轮搜索过程中，参考矩阵V，枚举S可达的所有数字，依次代入，看是否有解，找到是的结果最大的解即可。伪代码如下：

            

boolean search(char* num, int depth， int last) {
for i = 9 →0 {
if（V[last][i] = 1 ) {
if(search(num, depth+1, i) {
return true;
}
}
}
}

    由于i是倒序枚举的，因此，第一个找到的合法的结果一定是最大的结果。

    但是，上面的代码还有一个问题，就是没有考虑到“不大于K”这个条件，并不是每一轮的递归都可以从9开始枚举，这里设定一个标记tag，记录在进行当前搜索前，前面的搜索的结果是否和数字K中的对应位置相同，如果相同，tag为0， 否则：tag为1。例如对于数字65435，当进行到第3轮递归时，如果结果的前两位也是65，此时tag为1，那么为了保证结果不大于K，第三轮的搜索只能从K的第三位数字4开始，依次枚举：3,2,1,0；如果前两轮的结果是64，此时tag是1，那么由于高位已经有数位小于K，因此无论枚举的数字是多少，结果都不会大于K，此时可以枚举0-9的所有数字。

    因此，修改代码如下，在搜索前，先检查标识tag的值，如果是0，就从K值的对应数位的数字开始搜索，如果是1，那么就从9开始搜索。而在搜索过程中，如果发现搜索的值小于K对应数位的值依然找不到合法结果，那么将tag置为1。例如某个数字的前几位是654...，当在第三轮的递归时发现第三位取4不可以得到合法的结果，那么这说明第三位只能取比4小的数字，也就说明，后面的数位可以取0-9的任意值，因此将tag置为1。

    伪代码如下：

         

boolean search(char* num, int depth， int last) {
if(tag = 0) {
start = num[depth];
} else {
start = 9;
}
for i = start →0 {
if(i < num[depth]) {
tag = 1;
}
if（V[last][i] = 1 ) {
if(search(num, depth+1, i) {
result[depth] = i;
return true;
}
}
}
}

最后搜索完毕后，输出result中存储的内容即可。

输入输出格式：
    输入：输入的第一行为一个数字T，代表有T组测试数据；接下来的T行，每一行为一个数字K。
    输出：对于每一组测试数据，输出一个值，代表可以得到的不大于K的最大值。

数据范围：
    1≤K≤10^500
    1≤T≤20

程序代码：

/****************************************************/
/* File        : hiho_week_85.cpp                   */
/* Author      : Zhang Yufei                        */
/* Date        : 2016-02-20                         */
/* Description : HihoCoder ACM program. (submit:g++)*/
/****************************************************/

/*
* Update log:
*		Create by Zhang Yufei in 2016-02-20.
*			Submit: AC.
*/

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

/*
* The visitable matrix. If there exist path from number i to j,
* the value is 1, or 0.
*/
int matrix[10][10] = {
{1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
{1, 0, 1, 1, 0, 1, 1, 0, 1, 1},
{0, 0, 0, 1, 0, 0, 1, 0, 0, 1},
{1, 0, 0, 0, 1, 1, 1, 1, 1, 1},
{1, 0, 0, 0, 0, 1, 1, 0, 1, 1},
{0, 0, 0, 0, 0, 0, 1, 0, 0, 1},
{1, 0, 0, 0, 0, 0, 0, 1, 1, 1},
{1, 0, 0, 0, 0, 0, 0, 0, 1, 1},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 1}
};

/*
* The input number.
*/
char K[550];

/*
* The length of input K.
*/
int length;

/*
* This is a tag, indicating if program can iterate from 9.
* If tag equals 1, program iterates starting from 9, or from num[depth].
*/
int tag;

/*
* Store the result to output.
*/
char result[550];

/*
* This function deals with one input case.
* Parameters:
*		None.
* Returns:
*		None.
*/
void function(void);

/*
* This function search the answer for one test case,
* using iterating method.
* Parameters:
*		@num: The number in input.
*		@depth: The depth of iterate, it also means the position of the number
*				to deal with.
*		@last: The last number deal with in the last iterating.
* Returns:
*		If program finds an answer, return 1, or 0.
*/
int search(char* num, int depth, int last);

/*
* The main program.
*/
int main(void) {
int T;
scanf("%d", &T);
for(int i = 0; i < T; i++)
function();

return 0;
}

/*
* This function deals with one input case.
* Parameters:
*		None.
* Returns:
*		None.
*/
void function(void) {

scanf("%s", K);
length = strlen(K);
tag = 0;
search(K, 0, 1);

printf("%s\n", result);
}

/*
* This function search the answer for one test case,
* using iterating method.
* Parameters:
*		@num: The number in input.
*		@depth: The depth of iterate, it also means the position of the number
*				to deal with.
*		@last: The last number deal with in the last iterating.
* Returns:
*		If program finds an answer, return 1, or 0.
*/
int search(char *num, int depth, int last) {
if(depth == length) {
result[depth] = '\0';
return 1;
}

int start;
if(tag == 0) {
start = num[depth] - 48;
} else {
start = 9;
}
for(int i = start; i >= 0; i--) {
if(matrix[last][i]) {
if(i < num[depth] - 48) {
tag = 1;
}
if(search(K, depth + 1, i)) {
result[depth] = i + 48;
return 1;
}
}
}

return 0;
}