(原创)数位DP专题小结--by sgx

最新推荐文章于 2022-07-18 21:00:36 发布
最新推荐文章于 2022-07-18 21:00:36 发布
阅读量3.2k 收藏 2
点赞数 2
分类专栏： ACM_dp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012350533/article/details/12362105
版权
数位DP，一句话概括，就是在一个给定区间内求出满足某中奇葩条件的数字个数，这真是奇葩题目，但是总体写起来又有一定规律性。
主要可以分为以下几个步骤：

确定主体框架，确定一个大方向，想想该如何设计状态；
下面基本就是模板，直接DFS就行了，一位一位处理，这也是他叫按位DP的原因。
数位DP代码一般都很短，不过效率挺好，解决一些竞赛中出现的问题非常有用 。

如果看了这部分 ，你感觉还是不会的话，(这是当然啊，狂汗~~）,那么请继续往下看。
下面用几个例子来说明一下，具体注释都附在代码内：

PS：我是菜狗，这些都是很水的数位DP，求大神勿喷~~

————————————————————— ——华丽的分割线—————————————————————


Problem 1160 - 科协的数字游戏I
Time Limit: 1000MS      Memory Limit: 65536KB      Difficulty:    
Total Submit: 181     Accepted: 29     Special Judge: No 

Description

科协里最近很流行数字游戏。某人命名了一种不降数，这种数字必须满足从左到右各位数字成大于等于的关系，如123，446。现在大家决定玩一个游戏，指定一个整数闭区间[a,b]，问这个区间内有多少个不降数。

Input

题目有多组测试数据。每组只含2个数字a, b (1 <= a, b <= 2^31)。

Output

每行给出一个测试数据的答案，即[a, b]之间有多少阶梯数。

Sample Input

1 9
1 19

Sample Output

9
18

Hint

 

/********************************************************************
* Problem:科协的数字游戏2
* source:XDOJ
* author：sgx
* date：2013/09/15
*********************************************************************/
#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

#define LL long long

const int N=25;
int digit[N];
LL dp[N][N];

LL dfs(int pos,int statu,int limit)
{
     int i,end,s;
     LL res=0;
     if(pos==-1)
        return 1;
     if(!limit&&dp[pos][statu]!=-1)
        return dp[pos][statu];

     end=limit?digit[pos]:9;
     for(i=statu;i<=end;i++)
         res+=dfs(pos-1,i,limit&&i==end);
     if(!limit)
         dp[pos][statu]=res;
    return res;
}

LL calc(LL n)
{
     int len=0;
     memset(dp,-1,sizeof(dp));
     while(n)
     {
         digit[len++]=n%10;
         n/=10;
     }
     return dfs(len-1,0,1);
}

int main()
{
     LL a,b;
     while(scanf("%lld %lld",&a,&b)!=EOF)
         printf("%lld\n",calc(b)-calc(a-1));
    return 0;
}


 

————————————————————————————————————分割线—————————————————————————————————————

Problem 1161 - 科协的数字游戏II

Time Limit : 1000MS      Memory Limit : 65536KB      Difficulty :    
Total Submit : 108     Accepted : 13     Special Judge : No 
Description

由于科协里最近真的很流行数字游戏。（= =！汗一个）某人又命名了一种取模数，这种数字必须满足各位数字之和 mod N为0。现在大家又要玩游戏了，指定一个整数闭区间[a,b]，问这个区间内有多少个取模数。

Input
题目有多组测试数据。每组只含3个数字a, b, n (1 <= a, b <= 2^31,1 <= n < 100)。
Output
每个测试用例输出一行，表示各位数字和 mod N为0 的数的个数。
Sample Input
1 19 9
Sample Output
2
Hint

Source
tclh123

 

 

/********************************************************************
* Problem:科协的数字游戏2
* source:XDOJ
* 分析：记忆化搜索部分，pre表示前面各位数字之和对该数取模的结果
* author：sgx
* date：2013/09/15
*********************************************************************/
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>

using namespace std;

typedef long long LL;
const int maxn=100+5;

int dp[maxn][105];
int digit[maxn];

int mod,l,r;
int DFS(int pos,int pre,bool limit)
{
    if(pos==-1)
        return pre==0;
    if(!limit&&dp[pos][pre]!=-1)
        return dp[pos][pre];

     LL res=0,end=limit?digit[pos]:9;

     for(int i=0;i<=end;i++)
     {
        int new_pre=(pre+i)%mod;
         res+=DFS(pos-1,new_pre,limit&&i==end);
     }
     if(!limit)
         dp[pos][pre]=res;
    return res;
}

LL solve(int n)
{
     int len=0;
     while(n)
     {
         digit[len++]=n%10;
         n/=10;
     }
     return DFS(len-1,0,true);
}

int main()
{
     while(scanf("%d%d%d",&l,&r,&mod)!=EOF)
     {
         memset(dp,-1,sizeof(dp));
         printf("%lld\n",solve(r)-solve(l-1));
     }
     return 0;
}


 


————————————分割线————————

HDU3052--B-number

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 1556    Accepted Submission(s): 852
Problem Description

A wqb-number, or B-number for short, is a non-negative integer whose decimal form contains the sub- string "13" and can be divided by 13. For example, 130 and 2613 are wqb-numbers, but 143 and 2639 are not. Your task is to calculate how many wqb-numbers from 1 to n for a given integer n.
Input
Process till EOF. In each line, there is one positive integer n(1 <= n <= 1000000000).
Output
Print each answer in a single line.
Sample Input
13
100
200
1000
Sample Output
1
1
2
2

 

 

/**************************************************************
* 题意：求[1,n]内有多少个数字，该数字有13，且能被13整除 n<=10^9
即要满足x % 13 = 0；x=pre*10^pos+next;
 (pos代表处理到当前的位数，next代表正在处理的位置上面的数字)
 (pre*10^pos + next) % 13 = 0，pre是之前确定的部分；
 需要的参数为pre , pos ,状态用status表示
status==2记录pre拥有"13"，status==1是表示没有出现13，但是首位是1；
status=0表示没有13；

* Author:sgx
* Date:2013/09/15
*************************************************************************/

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>

using namespace std;

typedef long long LL;
const int maxn=100+5;

int dp[10][13][3];
int digit[10];

int DFS(int pos,int status,int pre,bool limit)
{
    if(pos==-1)
        return status==2&&pre==0;
    if(!limit&&dp[pos][pre][status]!=-1)
        return dp[pos][pre][status];

     LL res=0;
     int end=limit?digit[pos]:9;

     for(int i=0;i<=end;i++)
     {
        int new_pre=(pre*10+i)%13;
        int new_status=status;

        /*准备计算出下一阶段中新的状态status*/
        if(status==0&&i==1)
             new_status=1;/*原来没有出现13但是当前位是1，所以属于状态1对应的情况，故更新新状态为1；*/
        if(status==1&&i==1)
             new_status=1;/*解释方法同上*/
        else if(status==1&&i!=3)
             new_status=0;
        if(status==1&&i==3)
             new_status=2;

        res+=DFS(pos-1,new_status,new_pre,limit&&i==end);
        /*//limit==true则说明有限制,即所有可能并没有被全部记录,故此时记入dp数组 */
        //limit==false则说明之后的分支状态已经搜索完全
    }
    if(!limit)
         dp[pos][pre][status]=res;
    return res;
}

LL solve(int n)
{
     int len=0;
     while(n)
     {
         digit[len++]=n%10;
         n/=10;
     }
     return DFS(len-1,0,0,true);
}

int main()
{
     LL m,n;
     while(scanf("%lld",&n)!=EOF)
     {
         memset(dp,-1,sizeof(dp));
         printf("%lld\n",solve(n));
     }
     return 0;
}


 

HDU3555----BombTime Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/65536 K (Java/Others)
Total Submission(s): 4594    Accepted Submission(s): 1601
Problem Description

The counter-terrorists found a time bomb in the dust. But this time the terrorists improve on the time bomb. The number sequence of the time bomb counts from 1 to N. If the current number sequence includes the sub-sequence "49", the power of the blast would add one point.
Now the counter-terrorist knows the number N. They want to know the final points of the power. Can you help them?
Input
The first line of input consists of an integer T (1 <= T <= 10000), indicating the number of test cases. For each test case, there will be an integer N (1 <= N <= 2^63-1) as the description.

The input terminates by end of file marker.
Output
For each test case, output an integer indicating the final points of the power.
Sample Input
3
1
50
500
Sample Output
0
1
15

 

 

/******************************************************************
* PS:网上大神的文章真的太神了，改不了，贴过来
* 附个链接：http://blog.csdn.net/whyorwhnt/article/details/8764955
*******************************************************************/
#include <cstdio>
#include <cstring>

using namespace std;

int bit[25];
__int64 dp[25][3];
//dp[i][0]表示长度为i,没有49
//dp[i][1]表示长度为i,没有49但前一位为4
//dp[i][2]表示长度为i,包括49的个数

/*limit表示是否有上限,比如n=1234,现在转移到12,如果下一位选3,那么再下一位就有上限,
上限为4,如果不选3,那么下一位就没限制,最高位9,转移能保证转移到数比n小*/

__int64 Dfs (int pos,int s,bool limit) //s为之前数字的状态
{
     if (pos==-1)
        return s==2;
     if (limit==false && ~dp[pos][s])
        return dp[pos][s];
     int i ,end=limit?bit[pos]:9;
      __int64 ans=0;
     for (i=0;i<=end;i++)
     {
        int nows=s;
        if(s==0 && i==4)
             nows=1;
        if(s==1 && i!=9) //前一位为4
             nows=0;
        if(s==1 && i==4)
             nows=1;
        if(s==1 && i==9) //49
             nows=2;
         ans+=Dfs(pos-1 , nows , limit && i==end);
     }
    //limit==true则说明有限制,即所有可能并没有被全部记录,故此时记入dp数组
    //limit==false则说明之后的分支状态已经搜索完全
    return limit?ans:dp[pos][s]=ans;
}

int main ()
{
      __int64 n;
     int T;
     memset(dp,-1,sizeof(dp));
     scanf("%d",&T);
     while (T--)
     {
         scanf("%I64d",&n);
         int len=0;
         while (n)
         {
             bit[len++]=n%10;
             n/=10;
         }
         printf("%I64d\n",Dfs(len-1,0,1));
     }
     return 0;
}

 

HDU2089--不要62
Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 13687    Accepted Submission(s): 4402
Problem Description

杭州人称那些傻乎乎粘嗒嗒的人为62（音：laoer）。
杭州交通管理局经常会扩充一些的士车牌照，新近出来一个好消息，以后上牌照，不再含有不吉利的数字了，这样一来，就可以消除个别的士司机和乘客的心理障碍，更安全地服务大众。
不吉利的数字为所有含有4或62的号码。例如：
62315 73418 88914
都属于不吉利号码。但是，61152虽然含有6和2，但不是62连号，所以不属于不吉利数字之列。
你的任务是，对于每次给出的一个牌照区间号，推断出交管局今次又要实际上给多少辆新的士车上牌照了。
Input
输入的都是整数对n、m（0<n≤m<1000000），如果遇到都是0的整数对，则输入结束。
Output
对于每个整数对，输出一个不含有不吉利数字的统计个数，该数值占一行位置。
Sample Input
1 100
0 0
Sample Output
80


 

/********************************************************************
* Problem:HDU2089-不要62
* source:HDU
* 分析：记忆化搜索部分，i==4时要及时continue掉，不然无限WA；
* author：sgx
* date：2013/09/15
*********************************************************************/
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>

using namespace std;

typedef long long LL;
const int maxn=100+5;

int dp[maxn][3];
int digit[maxn];
//dp[i][0]表示长度为i,没有62
//dp[i][1]表示长度为i,没有62但前一位为6
//dp[i][2]表示长度为i,包括62的个数
int DFS(int pos,int status,bool limit)
{
    if(pos==-1)
        return status==2;
    if(!limit&&dp[pos][status]!=-1)
        return dp[pos][status];

     LL res=0,end=limit?digit[pos]:9;

     for(int i=0;i<=end;i++)
     {
        int new_status=status;

        if(i==4)
             new_status=2;
        else if(status==0&&i==6)
             new_status=1;
        else if(status==1&&i==6)
             new_status=1;
        else if(status==1&&i!=2)
             new_status=0;
        else if(status==1&&i==2)
             new_status=2;

         res+=DFS(pos-1,new_status,limit&&i==end);
     }
     if(!limit)
         dp[pos][status]=res;
     return res;
}

LL solve(int n)
{
     int len=0;
     while(n)
     {
         digit[len++]=n%10;
         n/=10;
     }
    return DFS(len-1,0,true);
}

int main()
{
     int n,m;
     while(scanf("%d%d",&n,&m)!=EOF&&(n+m))
     {
         memset(dp,-1,sizeof(dp));
         printf("%lld\n",m-n+1-solve(m)+solve(n-1));
     }
     return 0;
}

 

 

HDU4734F(x)
Time Limit: 1000/500 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 485    Accepted Submission(s): 179
Problem Description

For a decimal number x with n digits (A nA n-1A n-2 ... A 2A 1), we define its weight as F(x) = A n * 2 n-1 + A n-1 * 2 n-2 + ... + A 2 * 2 + A 1 * 1. Now you are given two numbers A and B, please calculate how many numbers are there between 0 and B, inclusive, whose weight is no more than F(A).
Input
The first line has a number T (T <= 10000) , indicating the number of test cases.
For each test case, there are two numbers A and B (0 <= A,B < 10 9)
Output
For every case,you should output "Case #t: " at first, without quotes. The t is the case number starting from 1. Then output the answer.
Sample Input
3
0 100
1 10
5 100
Sample Output
Case #1: 1
Case #2: 2
Case #3: 13 

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

using namespace std;

const int maxn=300;
const int maxm=6000;

int dp[maxn][maxm];
int a[maxn];

int DFS(int pos,int cur,int limit)
{
    int i,ed,s,ans=0;
    if(pos==-1)
        return cur>=0;
    if(!limit&&dp[pos][cur]!=-1)
        return dp[pos][cur];

     ed=limit?a[pos]:9;
     for(i=0;i<=ed;i++)
     {
         s=cur-i*(1<<pos);
        if(s<0)
            break;
         ans+=DFS(pos-1,s,limit&&i==ed);
     }

     if(!limit&&dp[pos][cur]==-1)
         dp[pos][cur]=ans;
     return ans;
}

int transfer(int n)
{
     int res=0,m=1;
     while(n)
     {
         res+=(n%10)*m;
         n/=10;
         m*=2;
     }
     return res;
}

int solve(int n,int m)
{
     int st=-1;
     while(m)
     {
         a[++st]=m%10;
         m/=10;
     }
     int res=DFS(st,transfer(n),1);
     return res;
}

int main()
{
     int test,n,m;
     scanf("%d",&test);
     memset(dp,-1,sizeof(dp));
     for(int ii=1;ii<=test;ii++)
     {
         scanf("%d%d",&n,&m);
         printf("Case #%d: %d\n",ii,solve(n,m));
     }
     return 0;
}


 

windy数

Description

windy定义了一种windy数。
不含前导零且相邻两个数字之差至少为2的正整数被称为windy数。
windy想知道，在A和B之间，包括A和B，总共有多少个windy数？

Input

包含两个整数，A B。
满足 1 <= A <= B <= 2000000000 。

Output

包含一个整数：闭区间[A,B]上windy数的个数。

Sample Input

1 10


Sample Output

9


纪念UESTC首A，@杜贵平 
艰难AC。。。。
/*******************************************************************
* problem:windy数
* source:UESTC1307
* author:sgx
* date:2013/09/18
********************************************************************/
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>

using namespace std;
const int maxn=20;

typedef long long LL;
LL dp[maxn][11];
LL digit[maxn];

LL DFS(int pos,int pre,bool limit,bool first_place)//first_place判断前导0
{
    if(pos==-1)
        return first_place==0;
    if(!limit&&dp[pos][pre]!=-1&&first_place==false)
        return dp[pos][pre];

     int end=limit?digit[pos]:9;
     LL ans=0;

     for(int i=0;i<=end;i++)
     {
        if(first_place!=0)
             ans+=DFS(pos-1,i,limit&&i==end,first_place&&i==0);
        else if(abs(i-pre)>=2)
             ans+=DFS(pos-1,i,limit&&i==end,first_place);
     }
     if(!limit&&first_place==false)
         dp[pos][pre]=ans;
     return ans;
}

LL solve(LL n)
{
     LL len=0;
     while(n)
     {
         digit[len++]=n%10;
         n/=10;
     }
     return DFS(len-1,0,true,true);
}


int main()
{

     LL l,r;
     while(scanf("%lld%lld",&l,&r)!=EOF)
     {
         memset(dp,-1,sizeof(dp));
         LL ans=solve(r)-solve(l-1);
         printf("%lld\n",ans);
     }
     return 0;
}




 
一名码农、
关注
专栏目录
sgx-emulator：英特尔SGX扩展的仿真器和SDK
02-05
本文将深入探讨"sgx-emulator"项目，这是一个专为英特尔Software Guard Extensions (SGX) 技术设计的仿真器和SDK。SGX是英特尔处理器中的一项硬件安全特性，它允许开发者创建受保护的内存区域，称为“安全 Enclaves...
sgx-lkl:SGX-LKL库操作系统，用于在Intel SGX安全区内运行Linux应用程序
04-30
SGX-LKL-OE（开放飞地版） 警告：此分支包含SGX-LKL的实验端口，可将Open Enclave用作安全区抽象层。 这是一个正在进行的研究项目。 各种功能正在开发中，并且存在几个已知的错误。 SGX-LKL项目旨在在Intel SGX...
hdu 4619 Warm up 2 ( 二分图最大匹配 )
Hadis_yuki
08-26 847
题目：Warm up 2 题意：有横竖两种方式放着的多米诺骨牌，相同方向的不可能重叠，但是横放和竖放的牌可能重叠。             移走重叠的牌使剩下的牌最多。 分析：二分图匹配：最大独立点=顶点数-最大匹配数              横放的为一个点集，竖放的为一个点集。 代码：
数位动态规划：数字游戏
少儿编程乔老师
12-08 677
数位动态规划：数字游戏
数位DP--＞不降数
hnjzsyjyj的专栏
09-10 1040
【算法分析】 数位DP问题，通常用于求给定区间 [L, R] 中满足题目要求的数的个数。这个要求很简单。但是，这个区间[L,R] 的范围一般都是令人绝望的大。比如 1e9 都算良心的了，常规的都是 1e18 甚至更大。可见，对区间[L,R]中每个数进行遍历判别显然是不可能的，因为必然会TLE，所以此时就需要借助数位DP来求解。 所谓数位DP，就是在数的位上进行DP。这样的话，即便对 1e30 的大数，只需在31个数位上进行运算，显然会很高效。数位DP典型的数位分解思路如下图所示： 所谓数位...
数位dp 之 不要62（数位dp入门题）
kitalekita的博客
07-23 588
数位dp 之 不要62（数位dp入门题） HDU-2089 不要62 Problem Description 杭州人称那些傻乎乎粘嗒嗒的人为62（音：laoer）。 杭州交通管理局经常会扩充一些的士车牌照，新近出来一个好消息，以后上牌照，不再含有不吉利的数字了，这样一来，就可以消除个别的士司机和乘客的心理障碍，更安全地服务大众。 不吉利的数字为所有含有4或62的号码。例如： 62315 73418 88914 都属于不吉利号码。但是，61152虽然含有6和2，但不是62连号，所以不属于不吉利数字之列。 你的
【LOJ10164】数字游戏
ETO的博客
09-28 770
题目描述 科协里最近很流行数字游戏。某人命名了一种不降数，这种数字必须满足从左到右各位数字成小于等于的关系，如 123123123，446446446。现在大家决定玩一个游戏，指定一个整数闭区间 [a,b][a,b][a,b]，问这个区间内有多少个不降数。 输入格式 有多组测试数据。每组只含两个数字 a,ba,ba,b，意义如题目描述。 输出格式 每行给出一个测试数据的答案，即 [a,b...
sgx-orchestrator:SGX感知容器协调器
05-18
SGX感知容器协调器 该存储库托管了我们的SGX感知容器协调器项目的技术文档和源代码。 我们的论文“异构集群的SGX感知容器编排”中描述了它的体系结构和实现，该论文将出现在。 本文还包含对调度程序本身的广泛评估，...
数位DP专题小结--by sgx 数位DP专题小结--by sgx
I good vegetable a!
08-14 557
数位DP，一句话概括，就是在一个给定区间内求出满足某中奇葩条件的数字个数，这真是奇葩题目，但是总体写起来又有一定规律性。 主要可以分为以下几个步骤： 确定主体框架，确定一个大方向，想想该如何设计状态； 下面基本就是模板，直接DFS就行了，一位一位处理，这也是他叫按位DP的原因。 数位DP代码一般都很短，不过效率挺好，解决一些竞赛中出现的问题非常有用 。 如果看了这部分 ，你感觉还
sgx-attestation-api-spec
最新发布
07-19
### sgx-attestation-api-spec 知识点详解 #### 一、Attestation Service for Intel® Software Guard Extensions (Intel® SGX) ##### 1.1 概述 Intel® Software Guard Extensions (Intel® SGX) 是一项由...
Luogu P2575 高手过招（博弈论）
dieyi0310的博客
09-03 204
睾♂手过招 题意描述：给定n个长度为20的，由0和1组成的序列。对于每个序列，都可以进行操作：将任意一个1移动到其右边的第一个0处。 每次可以选择任意一个序列中的任意一个1操作。不能操作者输。给定初始n个序列，求是否为必胜态。 题解： SG函数万岁 SG定理：对于任意一个状态 $ x $ ，如果其SG函数值 $ SG(x)=0 $ 则 $ x $ 为必败态，否则为必胜态。 定义其SG函数...
AcWing 1084. 数字游戏 II
逐梦er的博客
06-18 2586
题目描述 由于科协里最近真的很流行数字游戏。 某人又命名了一种取模数，这种数字必须满足各位数字之和 mod N 为 0。 现在大家又要玩游戏了，指定一个整数闭区间 [a.b]，问这个区间内有多少个取模数。 输入格式 输入包含多组测试数据，每组数据占一行。 每组数据包含三个整数 a,b,N。 输出格式 对于每个测试数据输出一行结果，表示区间内各位数字和 mod N 为 0 的数的个数。 数据范围 1≤a,b≤231−1, 1≤N<100 输入样例： 1 19 9 输出样例： 2 解题
动态规划--数位dp
weixin_61819021的博客
07-18 1052
dp
12.5在科协做了一天。iostream的学习
无知
12-05 742
1.FileInputStream,FileReader负责将数据从源读入缓冲区，  而缓冲流 BufferedReader  负责将数据从缓冲区读到内存。输出流一样的道理。2. try{}和catch(Exceptio e){}之间不能加任何语句，否则出错。3.  当一个方法的参数是一个对象时，把其类的子类传递给参数也是可以的。4.CharArrayWriter out=new Ch
数位dp小结
untilyouydc
02-04 274
数位dp小结 关于limit的问题 在数位dp中,limit的作用主要有两个。 控制枚举的界限，倘若没有界限，每一位的枚举范围都是0-9. 但如果有界限，那么可能不能取到9. 例如求1到311范围内不含有连续两个1的个数。当百位枚举到了3，那么如果你的十位只能枚举0-2. 控制剪枝的合法性： 很明显，相比于暴力搜索，数位dp唯一的优势就是剪枝。但剪枝往往会带来一些错误。在数位dp中，我们进行剪...
sgx-papers:关于Intel SGX的系统论文列表
05-02
sgx文件 使用/有关Intel SGX的系统论文的精选列表。 我将尝试使此列表保持更新。 我很高兴接受PR。 标题 会场 PDF格式 使用创新指令创建值得信赖的软件解决方案 HASP @ ISCA'13 用于多进程应用程序的库OS的协作和...
luoguP1043数字游戏
pandeng的博客
03-25 451
题目描述丁丁最近沉迷于一个数字游戏之中。这个游戏看似简单，但丁丁在研究了许多天之后却发觉原来在简单的规则下想要赢得这个游戏并不那么容易。游戏是这样的，在你面前有一圈整数（一共n个），你要按顺序将其分为m个部分，各部分内的数字相加，相加所得的m个结果对10取模后再相乘，最终得到一个数k。游戏的要求是使你所得的k最大或者最小。例如，对于下面这圈数字（n=4，m=2）：要求最小值时，((2-1) mod...
数位DP入门 —— hdu2089 不要62
Kruskal的博客
07-27 395
数位DP是一种用来计数的DP， 如果给你一道题， 让你去统计区间[l, r]之间满足某种条件的数字个数， 在没接触数位之前很容易想到的就是暴力判断。但当数据范围较大时这种方法就不可行了， 这时候我们就可能要用的差分的思想确定一个递推关系， 来更方便更高效的求解， 这就是数位DP。这种理论的东西可能写出来帮助不大， 数位DP的思想是通过自己对问题的思考逐渐建立的， 下面是我选的一个例题来帮助初步理解...
(数位DP 1.1)hdu 2089 不要62(求一个区间[a,b]中不包含4,64的数的个数)
黄俊东的专栏
04-13 2243
题目：不要62Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 23759    Accepted Submission(s): 8128Problem Description杭州人称那些傻乎乎粘嗒嗒的人为62（音：laoer）。杭州交通管理
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值