今日头条 2018 AI Camp 5 月 26 日在线笔试编程题第一道——最佳路径

题目

给定一个 n*m 的矩阵 A ，矩阵中每一个元素为一个十六进制数。寻找一条从左上角都右下角的路径，每次只能向右或者向下移动， 
使得路径上所有数字之积在 16 进制下的后缀 0 最少。

输入描述：

第一行：n, m (2 <= n,m <= 1000) 
接下来 n 行，每行 m 个 16 进制整数 0<=aij<=1090<=aij<=109

输出描述：

第一行：最少后缀 0 的个数(十进制) 
第二行：路径方案，从左上角开始，”>” 代表向右移动，”V” 代表向下移动。 
如果有多种方案，输出字典序最小的方案(“>” 的字典序小于 “V”)。

示例：

• 输入

  3 3 
  3 2 8 
  c 8 8 
  2 a f

• 输出

  1 
  ‘>>VV’(此处输出实际上没有引号)

• 说明 
  从左上角到右下角的所有路径中， 0x3 * 0x2 * 0x8 * 0x8 * 0xf = 0x1680 后缀 0 最少为 1， 且路径 “>>VV” 的字典序最小。

思路

• 首先需要设计一个函数来判断十六进制数字末尾零的个数。可以分为两种情况，小于 16 的数只有 0 末尾有一个零；大于等于 16 的数如果最后一位是 0，则肯定可以被 16 整除，若末尾是 0，我们对这个十六进制数向右移一位，也即除以 16，再看倒数第二位是否是零，这样一直往前判断直到某一位非零为止。

• 路径判断则用动态规划来实现。定义两个变量，第一个变量保存从左上角到每一个位置处的乘积，第二个变量保存是怎样从前一步到当前位置的，只有向右或者向下两种情况，用枚举表示。第一行只能向右走，第一列只能向下走，这是初始化情况。然后从第二行第二列开始进行判断，每一步比较从左边来的乘积和从上边来的乘积末尾含有零的个数，若二者不相等，则保存乘积和移动方向到相应变量中。若向下和向右二者相等，则需要分别向上和向左回溯到左上角倒序求出移动方向，然后从头开始比较，选择字典序小的路径作为最终的移动方向。

样例展示 (从左到右分别是原始数字、十六进制乘积和移动方向)

3 o	2 (6) (>)	8 (30) (>)
c (24) (V)	8 (30) (V)	8 (180) (V)
2 (48) (V)	a (1E0) (V)	f (1680) (V)

第二行第二个位置，从左边来是 24×8 = 120，末尾有 1 个 0；从上边来是 6×8 = 30，也有 1 个 0。 
从左边来路径是 V>，从右边来路径是 >V，由于 > 字典序小于 V，因此最终移动方向为 >V。

代码实现

#include <iostream>
#include <vector>
using namespace std;

int find_zero_num(int number);
int min_dictionary(int *direction, int i, int j, int col);
void find_route(int *direction, vector<int> &route, int m, int n, int col);

enum {RIGHT = , DOWN = }; //向下走为 1 ，向右走为 0

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

   int data[n][m];
   //保存矩阵中的数据
   long int product[n][m];
   //保存从左上角到位置(i, j)处的乘积
   int direction[n][m] = {};
   //保存位置(i, j)处的乘积是怎么得到的，1为从前一位置往下，0为从前一位置往右

   vector<int> route; //倒序保存路径

   int i = , j = ;

   for(i = ; i < n ; i++)
   {
       for(j = ; j < m; j++)
       {
           cin >> hex >> data[i][j];
       }
   }

   // 初始化第一列的乘积作为边界值
   product[][] = data[][];
   for(i = ; i < n; i++)
   {
       product[i][] = product[i-][] * data[i][];
       direction[i][] = DOWN;
   }

   // 初始化第一行的乘积作为边界值
   for(j = ; j < m; j++)
   {
       product[][j] = product[][j-] * data[][j];
       direction[][j] = RIGHT;
   }

   long int down = ;
   long int right = ;
   int flag = ;

   for(i = ; i < n; i++)
   {
       for (j = ; j < m; j++)
       {
           down = product[i-][j] * data[i][j]; //往下走的乘积
           right = product[i][j-] * data[i][j]; //往右走的乘积

           if (find_zero_num(down) < find_zero_num(right))
           {
               flag = ;
           }
           else if (find_zero_num(down) > find_zero_num(right))
           {
               flag = RIGHT;
           }
           else            //若向下和向右一样，则优先取字典序小的
           {
               if(min_dictionary(*direction, i, j, m))
               {
                   flag = DOWN;
               }
               else
               {
                   flag = RIGHT;
               }
           }

           if(!flag)
           {
               product[i][j] = right;
               direction[i][j] = RIGHT;
           }
           else
           {
               product[i][j] = down;
               direction[i][j] = DOWN;
           }
       }
   }

   cout << find_zero_num(product[n-][m-]) << endl;

   find_route(*direction, route, n-, m-, m);

   for(i = int(route.size()-); i >= ; i--)
   {
       if (route[i])
       {
           cout << 'V';
       }
       else
       {
           cout << '>';
       }
   }

   return ;
}

// find the zero number of a hex data
int find_zero_num(int number)
{
   int sum = ;
   if(number == )
   {
       sum = ;
   }
   while (number %  ==  && number >= )
   {
       sum++;
       number = number / ;
   }
   return sum;
}

int min_dictionary(int *direction, int i, int j, int col)
{
   vector<int> route_down;
   vector<int> route_right;

   int m = i - ;
   int n = j;
   find_route(direction, route_down, m, n, col); //向上回溯路线

   m = i;
   n = j - ;
   find_route(direction, route_right, m, n, col); //向左回溯路线

   int length = int(route_right.size());

   for (i = length - ; i >= ; i--) //从第一个不相等的位置处开始判断字典序
   {
       if (route_right[i] < route_down[i])
       {
           return ; //向右字典序小
       }
       if (route_right[i] > route_down[i])
       {
           return ; //向下字典序小
       }
   }

   return -;
}

// 从位置 (m, n) 处回溯路线，倒序保存在向量中
void find_route(int *direction, vector<int> &route, int m, int n, int col)
{
   while()
   {
       // 此位置乘积由上一位置向下移动得来，行数减一继续寻找
       if(direction[m * col + n] == )
       {
           m = m - ;
           route.push_back();
       }
       // 此位置乘积由上一位置向右移动得来，列数减一继续寻找
       else
       {
           n = n - ;
           route.push_back();
       }

       // 寻找至左上角，结束
       if (m ==  && n == )
       {
           break;
       }
   }
}

个人见解，如有错误，欢迎指正与交流！

获取更多精彩，请关注「seniusen」!