A seven segment display, or seven segment indicator, is a form of electronic display device for displaying decimal numerals that is an alternative to the more complex dot matrix displays. Seven segment displays are widely used in digital clocks, electronic meters, basic calculators, and other electronic devices that display numerical information.
Edward, a student in Marjar University, is studying the course "Logic and Computer Design Fundamentals" this semester. He bought an eight-digit seven segment display component to make a hexadecimal counter for his course project.
In order to display a hexadecimal number, the seven segment display component needs to consume some electrical energy. The total energy cost for display a hexadecimal number on the component is the sum of the energy cost for displaying each digit of the number. Edward found the following table on the Internet, which describes the energy cost for display each kind of digit.
|
|
|
For example, in order to display the hexadecimal number "5A8BEF67" on the component for one second, 5 + 6 + 7 + 5 + 5 + 4 + 6 + 3 = 41 units of energy will be consumed.
Edward's hexadecimal counter works as follows:
- The counter will only work for n seconds. After n seconds the counter will stop displaying.
- At the beginning of the 1st second, the counter will begin to display a previously configured eight-digit hexadecimal number m.
- At the end of the i-th second (1 ≤ i < n), the number displayed will be increased by 1. If the number displayed will be larger than the hexadecimal number "FFFFFFFF" after increasing, the counter will set the number to 0 and continue displaying.
Given n and m, Edward is interested in the total units of energy consumed by the seven segment display component. Can you help him by working out this problem?
Input
There are multiple test cases. The first line of input contains an integer T (1 ≤ T ≤ 105), indicating the number of test cases. For each test case:
The first and only line contains an integer n (1 ≤ n ≤ 109) and a capitalized eight-digit hexadecimal number m (00000000 ≤ m ≤ FFFFFFFF), their meanings are described above.
We kindly remind you that this problem contains large I/O file, so it's recommended to use a faster I/O method. For example, you can use scanf/printf instead of cin/cout in C++.
Output
For each test case output one line, indicating the total units of energy consumed by the eight-digit seven segment display component.
Sample Input
3 5 89ABCDEF 3 FFFFFFFF 7 00000000
Sample Output
208 124 327
Hint
For the first test case, the counter will display 5 hexadecimal numbers (89ABCDEF, 89ABCDF0, 89ABCDF1, 89ABCDF2, 89ABCDF3) in 5 seconds. The total units of energy cost is (7 + 6 + 6 + 5 + 4 + 5 + 5 + 4) + (7 + 6 + 6 + 5 + 4 + 5 + 4 + 6) + (7 + 6 + 6 + 5 + 4 + 5 + 4 + 2) + (7 + 6 + 6 + 5 + 4 + 5 + 4 + 5) + (7 + 6 + 6 + 5 + 4 + 5 + 4 + 5) = 208.
For the second test case, the counter will display 3 hexadecimal numbers (FFFFFFFF, 00000000, 00000001) in 3 seconds. The total units of energy cost is (4 + 4 + 4 + 4 + 4 + 4 + 4 + 4) + (6 + 6 + 6 + 6 + 6 + 6 + 6 + 6) + (6 + 6 + 6 + 6 + 6 + 6 + 6 + 2) = 124.
题意：给出一个16进制数，自身+n-1。超过FFFFFFFF后从0开始算。每个数的贡献如图所示。问贡献和为多少。
题解：自己 是模拟了一下，别人说是数位dp ，也没想到怎么p，就说一下怎么模拟吧。
我们就按最低位开始操作，没到达一位，定义变量 liu 代表前面的数，全都进位的话，需要增加多少，因为只有进位了，当前的数才会改变，如果liu >= n 后面的数也都不会改变了，直接每个数对应的数量*n即可; 若liu<n,说明当前位肯定会进位，先判断会循环多少次，在确定最后停留的数是啥，注意，最后停留的数，可能是因为没进位，所以判断一下。见代码介绍
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
#include<algorithm>
#include<stack>
#include<cmath>
#include<map>
#include<cstring>
using namespace std;
typedef long long ll;
ll n,m;
ll ans;
char s[10];
map<char, ll> p;
char cul(char c,int x)// 计算该数 加 x后变为 啥
{
int ans=0;
if(c>='0'&&c<='9')
ans=c-'0';
else
ans=c-'A'+10;
ans=(ans+x)%16;
if(ans>=0&&ans<=9) return '0'+ans;
return 'A'+(ans-10);
}
ll cul1(char c,ll x) // 该数进位需要多少
{
ll ans;
if(c>='0'&&c<='9') ans=c-'0';
else ans=c-'A'+10;
return x*(15-ans);
}
void dfs(int pos,ll liu,ll val) // 当前位置 该数进位需要的次数 当前位置的权值 比如第二位16
{
if(pos<=0) return;
if(liu>=n) // 判断 是否还可以进位
{
liu=n;
ans+=(ll)p[s[pos]]*(ll)n;
dfs(pos-1,liu,val);
return;
}
ans+=(ll)p[s[pos]]*(ll)liu; //原始数字停留了多少次
ll mm=n-liu;
ans+=(ll)(mm/val/16)*(ll)val*(ll)m;//剩余次数可以循环多少次
for(int i=1;i<=(mm/val)%16;i++)//最后经过哪些数
{
ans+=(ll)p[cul(s[pos],i)]*(ll)val;
}
// 时候进最后一次位
if((ll)mm%((ll)val))ans+=(ll)p[cul(s[pos],mm/val+1)]*(ll)(mm%val);
dfs(pos-1,(ll)liu+cul1(s[pos],val),(ll)val*16);
}
int main()
{
p['0']=6;p['1']=2;p['2']=5;p['3']=5;p['4']=4;p['5']=5;p['6']=6;
p['7']=3;p['8']=7;p['9']=6;p['A']=6;p['B']=5;p['C']=4;p['D']=5;
p['E']=5;p['F']=4;
m=78;
int T,x;
scanf("%d",&T);
while(T--)
{
ans=0;
scanf("%lld%s",&n,s+1);
dfs(8,1,1);
printf("%lld\n",ans);
}
return 0;
}